home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 February: Tool Chest / Apple Developer CD Series Tool Chest February 1996 (Apple Computer)(1996).iso / Tool Chest / Interapplication Communication / AE Sample Applications / 7Edit / C Sources / SVAppleEvents.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-03-23  |  162.7 KB  |  5,937 lines  |  [TEXT/MPS ]
  1. /* 
  2.     SVAppleEvents.c 
  3.   
  4.     Version 3.0d9
  5.     
  6.     Copyright © SRL Data 1992, 1993
  7.     
  8.     All rights reserved
  9.     
  10.     Produced by : SRL Data
  11.     Originally Developed for UK.DTS
  12.     
  13.     The AppleEvent handling routines for the 7Edit example program
  14.     
  15.     This file includes :
  16.     
  17.         a) the code for the AppleEvent initialisation 
  18.         b) the routines for all the Edition Manager events
  19.         c) the Apple® Event Object Support
  20.  
  21. */
  22.  
  23. /* New for 3.0d1 :
  24.         Recommenting of many functions to improve clarity.
  25.         Implementation of nearly all menu commands via Apple Events.
  26.         Page Setup on each window (with visible page breaks)
  27.         Show Borders on each window with bug fixes in display.
  28.         
  29.     New for 3.0d2 :
  30.         19-Feb-92 : NH : Implement printing
  31.                      Fix drawing on scrollbar on show page breaks
  32.                                          Make IssueAEOpenDoc a function (for printing)
  33.                                          Make Paste Styled
  34.         
  35.         21-Feb-92 : NH : Use new (in SVEditions.p) calls for updating section info.
  36.         
  37.         27-Feb-92 : NH : SendTextMessage zapped and other routines used solely by it.
  38.         
  39.         
  40.          5-Mar-92 : NH : Added HandleCreatePub, IssueCreatePub
  41.         18-Mar-92 : NH : Zap PoseMessageDialog& mod AdornDefault
  42.         27-Mar-92 : NH : Call AssocAllSections when saved
  43.         
  44.         Start of updating to constants in Winter AERegistry.
  45.         
  46.   New for 3.0d3 :
  47.         16-Jun-92 : NH : Continue updating to match latest registry.
  48.                          typeText gone - now typeChar
  49.                                          classes of kAECut etc. changed (see registry)
  50.                                          Added pIsModified code.
  51.         17-Jun-92 : NH : Modify HandleSetData - Use AEResolve to yield tokenDescriptor, then
  52.                          extract appropriate token data.
  53.         18-Jun-92 : NH : Tidy up
  54.                                          Fix AEDescs being left after send of events
  55.                          Ensure SendAESetObjProp zaps all supplied params - now VAR params
  56.                                          Zap AEDescs left behind in HandleGetData.
  57.         24-Jun-92 : NH : Zap AddNamedStyleItem, AddNamedStyleItem, BuildStyleDescList
  58.                          Add code for typeTextStyles as per registry.
  59.                                          DoOpenDocument fixed to cope with no files in list etc.
  60.                                          Fixed buggy cast of windowToken to DPtr in DoCloseWindow
  61.                                          HandleShowSelection modified to take textTokens and WindowTokens
  62.                                          
  63.         25-Jun-92 : NH : StyleToName zapped
  64.         
  65.     Changes for 3.0d4 :
  66.        3-Jul-92 : NH : Fix SetWindowProperty typeMyText
  67.          7-Jul-92 : NH : Add missing window props - pIsFloating, pHasCloseBox, pIsZoomable
  68.         13-Jul-92 : NH : Complete the menu classes.
  69.                          Allow -ve absolute positions - i.e. last line of ...
  70.                                          Change Line access to allow relative offsets
  71.       14-Jul-92 : NH : Change region massages for window positions (thanks huggy!)
  72.         15-Jul-92 : NH : Modified HandleGetData/SetData to allow styledText and typeChar
  73.                          Recording of keyStrokes
  74.         17-Jul-92 : NH : Enter key -> compile text - filtered out too
  75.                          Fix setting of styles so that styles not in on/off styles untouched
  76.          5-Aug-92 : NH : Add pUserSelection
  77.                                           Zap cSelection
  78.                                          Added MakeSelectedTextObject for Gustav
  79.                                          Styles made to match behaviour in Inside Mac VI
  80.                                          Fixed setting of styles to match registry
  81.                                          Fixed saving to work after name change of window
  82.                                          Mark document as dirty after SetData
  83.                                          Feed back all filing errors
  84.                                          Moved some data from descriptor procedures to SVEditAEUtils.c
  85.                                          
  86.     Changes for 3.0d5: 
  87.         10-Aug-92 : NH : Fixed Quit save no - AEInteractWithUser called now
  88.                                          Added IssueQuitCommand.
  89.                                          Install cLine from typeMyText accessor
  90.     Changes for 3.0d6: 
  91.     
  92.         9-Sep-92 : JL : Added a check for gRecording implemented when sending an
  93.                                         event to ourselves for recording.
  94.     
  95.     Changes for 3.0d7: 
  96.         16-Nov-92 : JL : Changed pUserSelection to pSelection
  97.         
  98.     Changes for 3.0d9
  99.         03-Dec-93     <smd>    modified code to compile with universal headers
  100.                                             (powerpc compatible).
  101. */
  102.  
  103. #include <AppleEvents.h>
  104. #include <LowMem.h>
  105. #include <Menus.h>
  106. #include <PLStringFuncs.h>
  107. #include <Scrap.h>
  108. #include <TextEdit.h>
  109. #include <AEObjects.h>
  110. #include <AEPackObject.h>
  111. #include <AERegistry.h>
  112. #include "SVEditGlobals.h"
  113. #include "SVEditUtils.h"
  114. #include "SVEditAEUtils.h"
  115. #include "SVEditWindow.h"
  116. #include "SVEditFile.h"
  117. #include "SVAppleEvents.h"
  118.  
  119. /* these should come from the registry */
  120.         
  121. #define         kAEStartedRecording   'rec1'
  122. #define         kAEStoppedRecording        'rec0'
  123. #define         kAEDontExecute                 0x00002000
  124.  
  125. #define         pText                          'TEXT'
  126. #define     cSpot             'cspt'
  127.  
  128. /*
  129.     Text Properties
  130. */
  131.         
  132. #define         pStringWidth            'pwid'
  133.         
  134. /*
  135.     Window Properties - See the Registry for Details
  136. */
  137.         
  138. #define     pPosition                'ppos'
  139. #define         pPageSetup                'PSET' /* One of ours - Not in registry */
  140. #define         pShowBorders            'PBOR' /* Another of ours */
  141.                 
  142. #define         typeTPrint                'TPNT' /* A raw TPrint record - also one of ours */
  143.                         
  144. /*
  145.     Error Codes
  146. */
  147.         
  148. #define         kAEGenericErr    -1799
  149.  
  150. static short   gBigBrother;
  151. static char    *gTypingBuffer;
  152. static short   gCharsInBuffer;
  153. static AEDesc  gTypingTargetObject;
  154.  
  155. /*-----------------------------------------------------------------------*/
  156. /**----------                         APPLE EVENT HANDLING                     ---------------**/
  157. /*-----------------------------------------------------------------------*/
  158.  
  159. pascal OSErr GetTHPrintFromDescriptor(const AEDesc *sourceDesc, THPrint *result)
  160.   {
  161.       OSErr   myErr;
  162.         OSErr   ignoreErr;
  163.         Size    ptSize;
  164.         AEDesc  resultDesc;
  165.         
  166.         myErr = AECoerceDesc(sourceDesc,typeTPrint,&resultDesc);
  167.         
  168.         *result = nil;
  169.         
  170.         if (myErr==noErr) 
  171.             {
  172.                 *result = (THPrint)NewHandle(sizeof(TPrint));
  173.                 
  174.                 PrOpen();
  175.                 PrintDefault(*result);
  176.                 
  177.                 HLock((Handle)*result);
  178.     
  179.                 GetRawDataFromDescriptor(&resultDesc,
  180.                                                                  (Ptr)**result,
  181.                                                                  sizeof(TPrint),
  182.                                                                  &ptSize);
  183.                                                                  
  184.                 HUnlock((Handle)*result);
  185.                 
  186.                 if ((ptSize<sizeof(TPrint)) || (PrValidate(*result)))
  187.                     {
  188.                         myErr = errAECoercionFail;
  189.                         DisposHandle((Handle)*result);
  190.                         *result = nil;
  191.                     }
  192.                 
  193.                 PrClose();
  194.             }
  195.         
  196.         if (resultDesc.dataHandle) 
  197.             ignoreErr = AEDisposeDesc(&resultDesc);
  198.             
  199.         return(myErr);
  200.     } /*GetTHPrintFromDescriptor*/
  201.  
  202. /*******************************************************************************/
  203. /*
  204.     Object Accessors - Utility Routines
  205. */
  206.  
  207. #pragma segment ObjectAccessors
  208.  
  209. pascal WindowPtr WindowNameToWindowPtr(StringPtr nameStr)
  210. /* 
  211.     Returns the WindowPtr of the window with title nameStr
  212.     or nil if there is no matching window.
  213. */
  214.     { 
  215.         WindowPtr theWindow;
  216.         Str255    windTitle;
  217.             
  218.         theWindow =(WindowPtr)LMGetWindowList();
  219.         /* 
  220.             iterate through windows - we use WindowList 'cos we could
  221.             have made the window invisible and  we lose it - so we
  222.             can't set it back to visible!!
  223.         */
  224.         while (theWindow)
  225.             {
  226.                 GetWTitle(theWindow, windTitle);
  227.                 if (EqualString(windTitle,
  228.                                 nameStr,
  229.                                                 false,
  230.                                                 true))     /* ignore case, don't ignore diacriticals */
  231.                     return(theWindow);
  232.               theWindow = (WindowPtr)((WindowPeek)theWindow)->nextWindow;
  233.             }
  234.         return(theWindow);
  235.     }    /* WindowNameToWindowPtr */
  236.  
  237. pascal WindowPtr GetWindowPtrOfNthWindow(short index)
  238. /* returns a ptr to the window with the given index
  239.   (front window is 1, behind that is 2, etc.).  if
  240.   there's no window with that index (inc. no windows
  241.   at all), returns nil.
  242. */
  243.   {
  244.       WindowPtr theWindow;
  245.         
  246.         theWindow = (WindowPtr)LMGetWindowList();
  247.     
  248.         /* iterate through windows */
  249.         
  250.         while (theWindow)
  251.             {
  252.                 index --;
  253.                 if (index <= 0) 
  254.                     return(theWindow);
  255.                     
  256.               theWindow = (WindowPtr)((WindowPeek)theWindow)->nextWindow;
  257.             }
  258.         return(nil);
  259.     }    /* GetWindowPtrOfNthWindow */
  260.     
  261. pascal short CountWindows(void)
  262.     {
  263.         WindowPtr theWindow;
  264.         short     index;
  265.                 
  266.         index = 0;
  267.         theWindow = (WindowPtr)LMGetWindowList();
  268.     
  269.         /* iterate through windows */
  270.         
  271.         while (theWindow)
  272.             {
  273.                 index++;                    
  274.               theWindow = (WindowPtr)((WindowPeek)theWindow)->nextWindow;
  275.             }
  276.         
  277.         return(index);
  278.         
  279.     } /*CountWindows*/
  280.     
  281. pascal short ItemForNamedFont(Str255 theName)
  282.     {
  283.       Str255  itemName;
  284.         short   limit;
  285.     
  286.         limit = CountMItems(myMenus[fontM]);
  287.         while (limit>0)
  288.             {
  289.                 GetItem(myMenus[fontM],limit, itemName);
  290.                 if (IUEqualString(theName, itemName)==0) 
  291.                     return(limit);
  292.                 else
  293.                     limit--;
  294.             }
  295.         return(0);
  296.     } /*ItemForNamedFont*/
  297.  
  298. /**-----------------------------------------------------------------------
  299.         Name:             DoOpenApp
  300.         Purpose:        Called on startup, creates a new document.
  301.     -----------------------------------------------------------------------**/
  302.  
  303. #pragma segment Main
  304.  
  305. pascal OSErr DoOpenApp(const AppleEvent *message,const AppleEvent *reply,long refcon)
  306.   {
  307. #pragma unused (reply,refcon, message)
  308.     
  309.       DPtr ourDoc;
  310.     
  311.         /*just create a new document*/
  312.         ourDoc = NewDocument(false);
  313.         
  314.         if (ourDoc)
  315.             {
  316.                 ShowWindow(ourDoc->theWindow);
  317.                 return(noErr);
  318.             }
  319.         else
  320.             return(-108);
  321.     }
  322.  
  323. /**-----------------------------------------------------------------------
  324.         Name:             DoOpenDocument
  325.         Purpose:        Open all the documents passed in the Open AppleEvent.
  326. -----------------------------------------------------------------------**/
  327.  
  328. #pragma segment Main
  329.  
  330. pascal OSErr DoOpenDocument(const AppleEvent *message, const AppleEvent *reply, long refcon)            
  331.   {
  332. #pragma unused (reply, refcon)
  333.  
  334.         long        index;
  335.         long        itemsInList;
  336.         AEKeyword   keywd;
  337.         OSErr       err;
  338.         OSErr       ignoreErr;
  339.         AEDescList  docList;
  340.         long        actSize;
  341.         DescType    typeCode;
  342.         FSSpec      theFSSpec;
  343.         
  344.         /*open the specified documents*/
  345.         
  346.         docList.dataHandle = nil;
  347.         
  348.         err = AEGetParamDesc(message, keyDirectObject, typeAEList, &docList);
  349.         
  350.         if (err==noErr)
  351.             err = AECountItems( &docList, &itemsInList) ;
  352.         else
  353.           itemsInList = 0;
  354.             
  355.         for (index = 1; index <= itemsInList; index++)
  356.             if (err==noErr)
  357.                 {
  358.                     err = AEGetNthPtr( &docList, index, typeFSS, &keywd, &typeCode,
  359.                                                          (Ptr)&theFSSpec, sizeof(theFSSpec), &actSize ) ;
  360.                     if (err==noErr)
  361.                       err = OpenOld(theFSSpec);
  362.                 }
  363.     
  364.       if (docList.dataHandle)
  365.             ignoreErr = AEDisposeDesc(&docList);
  366.             
  367.         return(err);
  368.     }
  369.  
  370. /**-----------------------------------------------------------------------
  371.         Name:             MyQuit
  372.         Purpose:        Quit event received- exit the program.
  373.     -----------------------------------------------------------------------**/
  374.  
  375. #pragma segment Main
  376.  
  377. pascal OSErr MyQuit(const AppleEvent *message,const AppleEvent *reply,long refcon)            
  378.     {
  379. #pragma unused (reply,refcon)
  380.     
  381.         DescType saveOpt;
  382.         OSErr    tempErr;
  383.         OSErr    myErr;
  384.         DescType returnedType;
  385.         long     actSize;
  386.         
  387.         saveOpt = kAEAsk; /* the default */
  388.         tempErr = AEGetParamPtr(message,
  389.                                                         keyAESaveOptions,
  390.                                                         typeEnumerated,
  391.                                                         &returnedType,
  392.                                                         (Ptr)&saveOpt,
  393.                                                         sizeof(saveOpt),
  394.                                                         &actSize);
  395.         
  396.         if (saveOpt != kAENo)
  397.             myErr = AEInteractWithUser(kAEDefaultTimeout, nil, nil);
  398.  
  399.       if (myErr == noErr)
  400.             DoQuit(saveOpt);
  401.         
  402.         return(myErr);
  403.     }
  404.  
  405. /**-----------------------------------------------------------------------
  406.         Name:             DoAppleEvent
  407.         Purpose:        Process and despatch the AppleEvent
  408.     -----------------------------------------------------------------------**/
  409.  
  410. #pragma segment Main
  411.  
  412. pascal void DoAppleEvent(EventRecord theEvent)
  413.   {
  414.       OSErr err;
  415.     
  416.       /*should check for your own event message types here - if you have any*/
  417.         
  418.         err = AEProcessAppleEvent(&theEvent);
  419.     }
  420.  
  421. /**-----------------------------------------------------------------------
  422.         Name:             MakeSelfAddress
  423.         Purpose:        Builds an AEAddressDesc for the current process
  424.     -----------------------------------------------------------------------**/
  425.     
  426. pascal OSErr MakeSelfAddress(AEAddressDesc *selfAddress)
  427.   {
  428.       ProcessSerialNumber procSerNum;
  429.     
  430.         procSerNum.highLongOfPSN = 0;
  431.         procSerNum.lowLongOfPSN  = kCurrentProcess;
  432.         
  433.         return(AECreateDesc(typeProcessSerialNumber,
  434.                                                 (Ptr)&procSerNum,
  435.                                               sizeof(procSerNum),
  436.                                                 selfAddress));
  437.         
  438.     } /* MakeSelfAddress */
  439.  
  440. /**--------------------------------------------------------------------
  441.     Name : SendAESetObjProp
  442.     Function : Creates a property object from an object,
  443.                          a property type and its data and sends it to
  444.                          the requested address, and cleans up zapping params too
  445.     --------------------------------------------------------------------**/
  446.  
  447. pascal OSErr SendAESetObjProp(AEDesc        *theObj,
  448.                                                             DescType      theProp,
  449.                                                             AEDesc        *theData,
  450.                                                             AEAddressDesc *toWhom)
  451.                                                      
  452.     {
  453.        AEDesc     propObjSpec;
  454.          AppleEvent myAppleEvent;
  455.          AppleEvent defReply;
  456.          OSErr      myErr;
  457.          OSErr      ignoreErr;
  458.          AEDesc     theProperty;
  459.             
  460.         /* create an object spec that represents the property of the given object */
  461.         
  462.         myErr = AECreateDesc(typeType,
  463.                                                  (Ptr)&theProp,
  464.                                                  sizeof(theProp),
  465.                                                  &theProperty);
  466.         if (myErr==noErr)
  467.             myErr = CreateObjSpecifier(cProperty,
  468.                                                                  theObj,
  469.                                                                  formPropertyID,
  470.                                                                  &theProperty,
  471.                                                                  true,
  472.                                                                  &propObjSpec);    
  473.             
  474.         /* create event */
  475.         
  476.         if (myErr==noErr)
  477.             myErr = AECreateAppleEvent(kAECoreSuite,
  478.                                                                  kAESetData,
  479.                                                                  toWhom,
  480.                                                                  0,
  481.                                                                  0,
  482.                                                                  &myAppleEvent);
  483.             
  484.         /* add prop obj spec to the event */
  485.         
  486.         if (myErr==noErr)
  487.             myErr = AEPutParamDesc(&myAppleEvent, keyDirectObject, &propObjSpec);
  488.         
  489.         /* add prop data to the event */
  490.         
  491.         if (myErr==noErr)
  492.             myErr = AEPutParamDesc(&myAppleEvent,keyAEData, theData);
  493.         
  494.         /* send event */
  495.         
  496.         if (myErr==noErr)
  497.             myErr = AESend(&myAppleEvent,
  498.                                          &defReply,
  499.                                          kAENoReply+kAEAlwaysInteract,
  500.                                          kAENormalPriority,
  501.                                          kAEDefaultTimeout,
  502.                                          nil,
  503.                                          nil);
  504.         
  505.         if (myAppleEvent.dataHandle)
  506.             ignoreErr = AEDisposeDesc(&myAppleEvent);
  507.             
  508.         if (&propObjSpec.dataHandle)
  509.           ignoreErr = AEDisposeDesc(&propObjSpec);
  510.         
  511.         if (theData->dataHandle)
  512.             ignoreErr = AEDisposeDesc(theData);
  513.         
  514.         if (toWhom->dataHandle)
  515.             ignoreErr = AEDisposeDesc(toWhom);
  516.         
  517.         return(myErr);
  518.         
  519.     }    /* SendAESetObjProp */
  520.  
  521. /*----------------------------------------------------------------------------------------------*/
  522. /*
  523.     Private AEObject definitions
  524. */
  525. #pragma segment AECommandHandlers
  526.  
  527. #define typeMyAppl       'BAPP' /* sig of my private token type for the app     - appToken   */
  528. #define typeMyWndw             'BWIN'    /* sig of my private token type for windows     - windowToken   */
  529. #define typeMyText           'BTXT'    /* sig of my private token type for text        - textToken     */
  530. #define typeMyTextProp   'BPRP'    /* sig of my private token type for text properties    - textPropToken */
  531. #define typeMyWindowProp 'WPRP'    /* sig of my private token type for window properties  - windowPropToken */
  532. #define typeMyApplProp   'APRP'    /* sig of my private token type for appl properties    - applPropToken */
  533. #define typeMyMenu       'MTKN' /* sig of my private token type for menus       - menuToken  */
  534. #define typeMyMenuItem   'ITKN' /* sig of my private token type for menus       - menuItemToken  */
  535. #define typeMyMenuProp   'MPRP' /* sig of my private token type for menu properties - menuPropToken  */
  536. #define typeMyItemProp   'IPRP' /* sig of my private token type for menu item properties  - menuItemPropToken  */
  537.     
  538. /* These are entirely private to our app - used only when resolving the object specifier */
  539.     
  540. typedef    ProcessSerialNumber appToken;
  541.     
  542. struct applPropToken{
  543.     appToken tokenApplToken;
  544.     DescType tokenApplProperty;
  545. };
  546.  
  547. typedef struct applPropToken applPropToken;
  548.                                         
  549. typedef    WindowPtr WindowToken;
  550.     
  551. struct windowPropToken{
  552.         WindowToken tokenWindowToken;
  553.         DescType    tokenProperty;
  554.     };
  555.     
  556. typedef struct windowPropToken windowPropToken;
  557.     
  558. struct TextToken{
  559.         WindowPtr tokenWindow;
  560.         short     tokenOffset;
  561.         short     tokenLength;
  562.     };
  563.                     
  564. typedef struct TextToken TextToken;
  565.  
  566. struct textPropToken{
  567.         TextToken propertyTextToken;
  568.         DescType  propertyProperty;
  569.     };
  570.                 
  571. typedef struct textPropToken textPropToken;                
  572.                                 
  573. /* Tokens related to menus */
  574.  
  575. struct MenuToken {
  576.     MenuHandle theTokenMenu;
  577.     short      theTokenID;
  578. };
  579.  
  580. typedef struct MenuToken MenuToken;
  581.  
  582. struct MenuItemToken {
  583.     MenuToken  theMenuToken;
  584.     short      theTokenItem;
  585. };
  586.  
  587. typedef struct MenuItemToken MenuItemToken;
  588.  
  589. struct MenuPropToken {
  590.     MenuToken  theMenuToken;
  591.     DescType   theMenuProp;
  592. };
  593.  
  594. typedef struct MenuPropToken MenuPropToken;
  595.  
  596. struct MenuItemPropToken {
  597.     MenuItemToken  theItemToken;
  598.     DescType       theItemProp;
  599. };
  600.  
  601. typedef struct MenuItemPropToken MenuItemPropToken;
  602.  
  603. /*
  604.     Name: GotRequiredParams
  605.     Function: Checks all parameters defined as 'required' have been read
  606. */                            
  607. pascal OSErr GotRequiredParams(const AppleEvent *theAppleEvent)
  608.     {
  609.       OSErr    myErr;
  610.         DescType returnedType;
  611.         Size     actSize;
  612.         
  613.         /* look for the keyMissedKeywordAttr, just to see if it's there */
  614.         
  615.         myErr = AEGetAttributePtr(theAppleEvent,
  616.                                                             keyMissedKeywordAttr,
  617.                                                             typeWildCard,
  618.                                                             &returnedType,
  619.                                                             nil,
  620.                                                             0,
  621.                                                             &actSize);
  622.         
  623.         if (myErr == errAEDescNotFound) 
  624.             return(noErr);            /* attribute not there means we got all req params */
  625.         else 
  626.             if (myErr == noErr)  
  627.                 return(errAEParamMissed);        /* attribute there means missed at least one */
  628.             else 
  629.                 return(myErr);        /* some unexpected arror in looking for the attribute */
  630.     }    /* GotReqiredParams */
  631.  
  632. /**--------------------------------------------------------------------
  633.     Name : SetSelectionOfAppleEventDirectObject
  634.     Function : Resolves the Direct Object into a text token and
  635.                          sets the selection of the specified document to that
  636.                          specified in the direct object.
  637.                          Returns the doc and TEHandle chosen.
  638.     --------------------------------------------------------------------**/
  639.  
  640. pascal OSErr SetSelectionOfAppleEventDirectObject(const AppleEvent *theAppleEvent,
  641.                                                                                                DPtr             *theDocument,
  642.                                                                                                 TEHandle         *theHTE)
  643.     {
  644.         OSErr     myErr;
  645.         DescType  returnedType;
  646.         long      actSize;
  647.         TextToken myTextToken;
  648.         OSErr     paramErr;
  649.         WindowPtr fWin;
  650.                     
  651.         paramErr = AEGetParamPtr( theAppleEvent,
  652.                                                             keyDirectObject,
  653.                                                             typeMyText,
  654.                                                             &returnedType,
  655.                                                       (Ptr)&myTextToken,
  656.                                                             sizeof(myTextToken),
  657.                                                             &actSize);
  658.               
  659.         myErr = GotRequiredParams(theAppleEvent);
  660.         
  661.         /* now let's work on the direct object, if any */
  662.         
  663.         if (paramErr == errAEDescNotFound) 
  664.             {
  665.                 /* no direct object; check we have a window */
  666.                 
  667.                 fWin = FrontWindow();
  668.  
  669.                 if (fWin == nil) 
  670.                     return(-1700); /* Generic Err */
  671.                     
  672.                 *theDocument = DPtrFromWindowPtr(fWin);
  673.                 *theHTE      = (*theDocument)->theText;
  674.             }
  675.         
  676.         if (paramErr == noErr) 
  677.             {
  678.                 /* got a text token */
  679.                 
  680.                 *theDocument = DPtrFromWindowPtr(myTextToken.tokenWindow);
  681.                 *theHTE      = (*theDocument)->theText;
  682.                 
  683.                 TESetSelect(myTextToken.tokenOffset-1,
  684.                             myTextToken.tokenOffset+myTextToken.tokenLength-1,
  685.                                         *theHTE);
  686.                 
  687.             }
  688.             
  689.         if ((paramErr!=noErr) &&
  690.             (paramErr!=errAEDescNotFound))
  691.              {
  692.                  *theDocument = DPtrFromWindowPtr(FrontWindow());
  693.                  *theHTE      = (*theDocument)->theText;
  694.              }
  695.                  
  696.         return(myErr);
  697.              
  698.     } /* SetSelectionOfAppleEventDirectObject */
  699.     
  700. /**--------------------------------------------------------------------
  701.     Name             : SetSelectionOfAppleEventObject
  702.     Function     : Resolves the whatObject type of the AppleEvent into a text
  703.                              token and sets the selection to be that specified in the
  704.                              text token.
  705.                              Returns the doc and TEHandle chosen.
  706.     --------------------------------------------------------------------**/
  707.  
  708. pascal OSErr SetSelectionOfAppleEventObject(OSType            whatObject,
  709.                                                                                     const AppleEvent *theAppleEvent,
  710.                                                                                      DPtr             *theDocument,
  711.                                                                                     TEHandle         *theHTE)
  712.     {
  713.         DescType   returnedType;
  714.         long       actSize;
  715.         TextToken  myTextToken;
  716.         OSErr      paramErr;
  717.             
  718.         paramErr  = AEGetParamPtr(theAppleEvent,
  719.                                                             whatObject,
  720.                                                             typeMyText,
  721.                                                             &returnedType,
  722.                                                       (Ptr)&myTextToken,
  723.                                                             sizeof(myTextToken),
  724.                                                             &actSize);
  725.                                       
  726.         if (paramErr == noErr) 
  727.             {
  728.                 /* got a text token */
  729.                 
  730.                 *theDocument = DPtrFromWindowPtr(myTextToken.tokenWindow);
  731.                 *theHTE      = (*theDocument)->theText;
  732.                 
  733.                 TESetSelect(myTextToken.tokenOffset-1,
  734.                             myTextToken.tokenOffset+myTextToken.tokenLength-1,
  735.                                         *theHTE);
  736.             }
  737.                              
  738.         return(paramErr);
  739.                  
  740.     } /* SetSelectionOfAppleEventObject */
  741.  
  742. /* -----------------------------------------------------------------------
  743.         Name:             DoCutEdit
  744.         Purpose:        Performs a cut text operation on the current text selection
  745.      -----------------------------------------------------------------------**/
  746.     
  747. pascal OSErr DoCutEdit(const AppleEvent *theAppleEvent, AppleEvent *reply ,long refCon)
  748.     {
  749. #pragma unused (reply,refCon)
  750.     
  751.       OSErr    myErr;
  752.       TEHandle theHTE;
  753.         DPtr     theDocument;
  754.     
  755.         myErr = SetSelectionOfAppleEventDirectObject(theAppleEvent,&theDocument,&theHTE);
  756.         
  757.         if (myErr==noErr) 
  758.             {
  759.               DoTECutSectionRecalc(theDocument);
  760.             
  761.                 myErr = (OSErr) ZeroScrap();
  762.                 TECut(theHTE);
  763.                 AdjustScrollbars(theDocument, false);
  764.                 DrawPageExtras(theDocument);
  765.                 theDocument->dirty = true;
  766.             }
  767.             
  768.         return(myErr);
  769.     } /* DoCutEdit */
  770.     
  771. /* -----------------------------------------------------------------------
  772.         Name:             DoCopyEdit
  773.         Purpose:        Performs a copy text operation on the text selection specified
  774.                                 by the appleEvent direct object (if any)
  775.      -----------------------------------------------------------------------**/
  776.     
  777. pascal OSErr DoCopyEdit(const AppleEvent *theAppleEvent,AppleEvent *reply, long refCon)
  778.     {
  779. #pragma unused (reply,refCon)
  780.     
  781.       OSErr    myErr;
  782.         TEHandle theHTE;
  783.         DPtr     theDocument;
  784.  
  785.         /*
  786.                 Here we extract the information about what to copy from the
  787.                 directObject - if any
  788.         */
  789.         
  790.         myErr = SetSelectionOfAppleEventDirectObject(theAppleEvent,&theDocument,&theHTE);
  791.         
  792.         if (myErr==noErr) 
  793.             {
  794.                 myErr = (OSErr) ZeroScrap();
  795.                 TECopy(theHTE);     
  796.             }
  797.             
  798.         if (myErr==noErr) 
  799.             if (SetSelectionOfAppleEventObject(keyAEContainer, 
  800.                                                                                  theAppleEvent,
  801.                                                                                  &theDocument,
  802.                                                                                  &theHTE) == noErr) 
  803.                 {
  804.                     DoTEPasteSectionRecalc(theDocument);
  805.                     
  806.                     TEStylPaste(theHTE);
  807.                     
  808.                     AdjustScrollbars(theDocument, false);
  809.                     
  810.                     DrawPageExtras(theDocument);
  811.                     
  812.                     theDocument->dirty = true;
  813.                 }
  814.             
  815.         return(myErr);
  816.     } /* DoCopyEdit */
  817.     
  818. /* -----------------------------------------------------------------------
  819.         Name:             DoPasteEdit
  820.         Purpose:        Performs a paste text operation on the text selection specified
  821.                                 by the appleEvent direct object (if any)
  822.      -----------------------------------------------------------------------**/
  823.     
  824. pascal OSErr DoPasteEdit(const AppleEvent *theAppleEvent,AppleEvent *reply, long refCon)
  825.     {
  826. #pragma unused (reply,refCon)
  827.     
  828.       OSErr    myErr;
  829.         TEHandle theHTE;
  830.         DPtr     theDocument;
  831.  
  832.         myErr = SetSelectionOfAppleEventDirectObject(theAppleEvent, &theDocument, &theHTE);
  833.         
  834.         if (myErr==noErr) 
  835.             {
  836.                 DoTEPasteSectionRecalc(theDocument);
  837.                 
  838.                 TEStylPaste(theHTE);     
  839.  
  840.                 AdjustScrollbars(theDocument, false);
  841.                 
  842.                 DrawPageExtras(theDocument);
  843.  
  844.                 theDocument->dirty = true;
  845.             }
  846.             
  847.         return(myErr);
  848.     } /* DoPasteEdit */
  849.     
  850. /* -----------------------------------------------------------------------
  851.         Name:             DoDeleteEdit
  852.         Purpose:        Performs a delete text operation on the selection specified
  853.                                 by the appleEvent direct object (if any)
  854.      -----------------------------------------------------------------------**/
  855.      
  856. pascal OSErr DoDeleteEdit(const AppleEvent *theAppleEvent,AppleEvent *reply, long refcon)
  857.     {
  858. #pragma unused (reply,refcon)
  859.     
  860.         OSErr     myErr;
  861.         TEHandle theHTE;
  862.         DPtr     theDocument;
  863.             
  864.         myErr = SetSelectionOfAppleEventDirectObject(theAppleEvent, &theDocument, &theHTE);
  865.         
  866.         if (myErr==noErr)
  867.             {
  868.                 DoTEDeleteSectionRecalc(theDocument);
  869.                         
  870.                 TEDelete(theHTE);     
  871.                 
  872.                 theDocument->dirty = true;
  873.                 AdjustScrollbars(theDocument, false);
  874.                 DrawPageExtras(theDocument);
  875.             }
  876.                     
  877.         return(myErr);
  878.     } /*DoDeleteEdit*/
  879.     
  880. /* -----------------------------------------------------------------------
  881.         Name:             SetTheFontOfTheTokenText
  882.         Purpose:        Sets the font of the text specified by theTextToken to 
  883.                                 the font in name.
  884.      -----------------------------------------------------------------------**/
  885.      
  886. pascal void SetTheFontOfTheTokenText(TextToken theTextToken, Str255 name)
  887.     {
  888.       DPtr      theDocument;
  889.         short     theNumber;
  890.         short     theItem;
  891.         GrafPtr   oldPort;
  892.         TextStyle newStyle;
  893.     
  894.         GetPort(&oldPort);
  895.         
  896.         theDocument = DPtrFromWindowPtr(theTextToken.tokenWindow);
  897.                 
  898.         GetFNum(name, &theNumber);
  899.         
  900.         theItem = ItemForNamedFont(name); /* returns 0 if failed - i.e. SystemFont */
  901.         
  902.         if (gFontMItem)
  903.             CheckItem(myMenus[fontM], gFontMItem, false);
  904.         
  905.         gFontMItem = theItem;
  906.         CheckItem(myMenus[fontM], gFontMItem, true);
  907.         
  908.         theDocument->theFont = theNumber;
  909.         
  910.         TESetSelect(theTextToken.tokenOffset-1,
  911.                                 theTextToken.tokenOffset+theTextToken.tokenLength-1,
  912.                                 theDocument->theText);
  913.         
  914.         newStyle.tsFont = theNumber;
  915.         TESetStyle(doFont, &newStyle, true, theDocument->theText); 
  916.         
  917.         AdjustScrollbars(theDocument, false);
  918.         DrawPageExtras(theDocument);
  919.         theDocument->dirty = true;
  920.         
  921.         SetPort(oldPort);
  922.     } /* SetTheFontOfTheTokenText */
  923.     
  924. /* -----------------------------------------------------------------------
  925.         Name:             SetTheSizeOfTheTokenText
  926.         Purpose:        Sets the size of the text specified by theTextToken to 
  927.                                 the size in theSize.
  928.      -----------------------------------------------------------------------**/
  929.      
  930. pascal void SetTheSizeOfTheTokenText(TextToken theTextToken, short theSize)
  931.     {
  932.         DPtr      theDocument;
  933.         GrafPtr   oldPort;
  934.         TextStyle newStyle;
  935.     
  936.         GetPort(&oldPort);
  937.         
  938.         theDocument = DPtrFromWindowPtr(theTextToken.tokenWindow);
  939.                                 
  940.         theDocument->theSize = theSize;
  941.         
  942.         TESetSelect(theTextToken.tokenOffset-1,
  943.                                 theTextToken.tokenOffset+theTextToken.tokenLength-1,
  944.                                 theDocument->theText);
  945.         
  946.         newStyle.tsSize = theSize;
  947.         TESetStyle(doSize, &newStyle, true, theDocument->theText); 
  948.         
  949.         AdjustScrollbars(theDocument, false);
  950.         DrawPageExtras(theDocument);
  951.         theDocument->dirty = true;
  952.         
  953.         SetPort(oldPort);
  954.     } /* SetTheSizeOfTheTokenText */
  955.     
  956. /* -----------------------------------------------------------------------
  957.         Name:             SetTheStyleOfTheTokenText
  958.         Purpose:        Sets the style of the text specified by theTextToken to 
  959.                                 the style in theStyle.
  960.      -----------------------------------------------------------------------**/
  961.      
  962. pascal void SetTheStyleOfTheTokenText(const TextToken *theTextToken, Style onStyle, Style offStyle)
  963.     {
  964.       DPtr      theDocument;
  965.         GrafPtr   oldPort;
  966.         TextStyle newStyle;
  967.         short     mode;
  968.         Boolean   wasContinuous;
  969.     
  970.         GetPort(&oldPort);
  971.         
  972.         theDocument = DPtrFromWindowPtr(theTextToken->tokenWindow);
  973.                                 
  974.         theDocument->theStyle = onStyle;
  975.         TESetSelect(theTextToken->tokenOffset-1,
  976.                                 theTextToken->tokenOffset+theTextToken->tokenLength-1,
  977.                                 theDocument->theText);
  978.         
  979.         // Check to see if off styles are on for whole selection
  980.         mode = doFace;
  981.         
  982.         wasContinuous = TEContinuousStyle(&mode, &newStyle, theDocument->theText);
  983.         if ((newStyle.tsFace & offStyle) != offStyle) // not off styles are on for all
  984.             {
  985.               // switch on across board so that toggle off will clear all
  986.             newStyle.tsFace  = offStyle - (newStyle.tsFace & offStyle);
  987.                 TESetStyle(doFace+doToggle, &newStyle, false, theDocument->theText); 
  988.             }
  989.             
  990.         newStyle.tsFace  = offStyle;
  991.         TESetStyle(doFace+doToggle, &newStyle,(onStyle==0), theDocument->theText); // toggle all to off
  992.         
  993.         mode = doFace;
  994.         if (onStyle)
  995.             {
  996.                 wasContinuous = TEContinuousStyle(&mode, &newStyle, theDocument->theText);
  997.                 if ((newStyle.tsFace & onStyle) != onStyle) // are they on for only a few chars
  998.                     { 
  999.                         // Need to make all chars have these characteristics
  1000.                     
  1001.                         newStyle.tsFace = onStyle - (newStyle.tsFace & onStyle); // take out those continuous
  1002.                         TESetStyle(doFace+doToggle, &newStyle, true, theDocument->theText);
  1003.                     }
  1004.                 else
  1005.                     TESetStyle(0, &newStyle, true, theDocument->theText); // Just Draw it, no changes
  1006.             }
  1007.             
  1008.         AdjustScrollbars(theDocument, false);
  1009.         DrawPageExtras(theDocument);
  1010.         theDocument->dirty = true;
  1011.         
  1012.         SetPort(oldPort);
  1013.     } /* SetTheStyleOfTheTokenText */
  1014.  
  1015. /* -----------------------------------------------------------------------
  1016.         Name:             SetWindowProperty
  1017.         Purpose:        Sets the window property specified in theWindowPropToken to
  1018.                                 be that supplied in dataDesc.
  1019.      -----------------------------------------------------------------------**/
  1020.      
  1021. pascal OSErr SetWindowProperty(const AEDesc *theWPTokenDesc, const AEDesc *dataDesc)
  1022.     {
  1023.       Str255          theNewName;
  1024.         DPtr            theDocument;
  1025.         OSErr           err;
  1026.         OSErr           ignoreErr;
  1027.         Rect            thePosnRect;
  1028.         Boolean         theBoolean;
  1029.         TEHandle        theHTE;
  1030.         GrafPtr         oldPort;
  1031.         Point           thePosn;
  1032.         THPrint         theTHPrint;
  1033.         windowPropToken theWindowPropToken;
  1034.         AEDesc          newDesc;
  1035.         AEDesc          tokenDesc;
  1036.         Size            tokenSize;
  1037.         TextToken       myTextToken;
  1038.         short           hOffset;
  1039.         short           vOffset;
  1040.     
  1041.         err = AECoerceDesc(theWPTokenDesc, typeMyWindowProp, &newDesc);
  1042.         
  1043.         if (err)
  1044.             return(err);
  1045.  
  1046.         GetRawDataFromDescriptor(&newDesc,
  1047.                                                          (Ptr)&theWindowPropToken,
  1048.                                                          sizeof(theWindowPropToken),
  1049.                                                          &tokenSize);
  1050.         
  1051.         err = AEDisposeDesc(&newDesc);
  1052.     
  1053.         GetPort(&oldPort);
  1054.         SetPort(theWindowPropToken.tokenWindowToken);
  1055.         
  1056.         theDocument = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  1057.         
  1058.         if (theWindowPropToken.tokenProperty == pName) 
  1059.             {
  1060.                 err = GetPStringFromDescriptor(dataDesc, (char *)theNewName);
  1061.                 if (err==noErr) 
  1062.                     if (theNewName[0] == 0) 
  1063.                         err = errAEWrongDataType;
  1064.                     else
  1065.                         {
  1066.                             SetWTitle(theWindowPropToken.tokenWindowToken, theNewName);
  1067.                             PLstrcpy(theDocument->theFileName, theNewName); /* Should we do this??? */
  1068.                             theDocument->dirty = true;
  1069.                         }
  1070.             }
  1071.             
  1072.         if (theWindowPropToken.tokenProperty == pText) 
  1073.             {
  1074.                 theHTE = theDocument->theText;
  1075.                 TESetSelect(0, 32000, theHTE);
  1076.                 
  1077.                 DoTEDeleteSectionRecalc(theDocument);
  1078.                 TEDelete(theHTE);
  1079.                 
  1080.                 err = GetStyledTextFromDescIntoTEHandle(dataDesc, theHTE);
  1081.  
  1082.                 theDocument->dirty = true;
  1083.             }
  1084.             
  1085.         if (theWindowPropToken.tokenProperty == pBounds) 
  1086.             {
  1087.                 err = GetRectFromDescriptor(dataDesc, &thePosnRect);
  1088.                 /* the rectangle is for the structure region, and is in global coordinates */
  1089.                 /* MoveWindow and SizeWindow apply to the content region, so we have to massage a little */
  1090.  
  1091.                 thePosnRect.top    += (**((WindowPeek)theWindowPropToken.tokenWindowToken)->contRgn).rgnBBox.top -
  1092.                                       (**((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn).rgnBBox.top;
  1093.                                                             
  1094.                 thePosnRect.left   += (**((WindowPeek)theWindowPropToken.tokenWindowToken)->contRgn).rgnBBox.left -
  1095.                                       (**((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn).rgnBBox.left;
  1096.                                                             
  1097.                 thePosnRect.bottom += (**((WindowPeek)theWindowPropToken.tokenWindowToken)->contRgn).rgnBBox.bottom -
  1098.                                       (**((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn).rgnBBox.bottom;
  1099.                                                             
  1100.                 thePosnRect.right  += (**((WindowPeek)theWindowPropToken.tokenWindowToken)->contRgn).rgnBBox.right -
  1101.                                       (**((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn).rgnBBox.right;
  1102.                 
  1103.                 if (EmptyRect(&thePosnRect)) 
  1104.                     err = errAECorruptData;
  1105.                 else
  1106.                     {
  1107.                         MoveWindow(theWindowPropToken.tokenWindowToken,
  1108.                                              thePosnRect.left,
  1109.                                              thePosnRect.top,
  1110.                                              false);
  1111.                         SizeWindow(theWindowPropToken.tokenWindowToken,
  1112.                                              thePosnRect.right- thePosnRect.left,
  1113.                                              thePosnRect.bottom-thePosnRect.top,
  1114.                                              true);
  1115.                         ResizeWindow(theDocument);
  1116.                     }
  1117.             }
  1118.  
  1119.         if (theWindowPropToken.tokenProperty == pPosition) 
  1120.             {
  1121.                 err = GetPointFromDescriptor(dataDesc, &thePosn);
  1122.                 /* the point is for the structure region, and is in global coordinates */
  1123.                 /* MoveWindow applies to the content region, so we have to massage a little */
  1124.         
  1125.                 hOffset = (**((WindowPeek)theWindowPropToken.tokenWindowToken)->contRgn).rgnBBox.left -
  1126.                           (**((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn).rgnBBox.left;
  1127.                                     
  1128.                 vOffset = (**((WindowPeek)theWindowPropToken.tokenWindowToken)->contRgn).rgnBBox.top -
  1129.                           (**((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn).rgnBBox.top;
  1130.                                     
  1131.                                     
  1132.                 thePosn.v  += vOffset;
  1133.                 thePosn.h  += hOffset;
  1134.                 
  1135.                 MoveWindow(theWindowPropToken.tokenWindowToken,
  1136.                                      thePosn.h,
  1137.                                      thePosn.v,
  1138.                                      false);
  1139.                                      
  1140.                 ResizeWindow(theDocument);
  1141.             }
  1142.  
  1143.         if (theWindowPropToken.tokenProperty == pIsZoomed) 
  1144.             {
  1145.                 err = GetBooleanFromDescriptor(dataDesc, &theBoolean);
  1146.                 if (theBoolean)
  1147.                     ZoomWindow(qd.thePort,
  1148.                                          inZoomOut,
  1149.                                          false);
  1150.                 else
  1151.                     ZoomWindow(qd.thePort,
  1152.                                          inZoomIn,
  1153.                                          false);
  1154.                                                          
  1155.                 ResizeWindow(theDocument);
  1156.             }
  1157.             
  1158.         if (theWindowPropToken.tokenProperty == pVisible) 
  1159.             {
  1160.                 err = GetBooleanFromDescriptor(dataDesc, &theBoolean);
  1161.                 if (theBoolean)
  1162.                     ShowWindow(theWindowPropToken.tokenWindowToken);
  1163.                 else
  1164.                     HideWindow(theWindowPropToken.tokenWindowToken);
  1165.             }
  1166.             
  1167.         if (theWindowPropToken.tokenProperty == pPageSetup) 
  1168.             {
  1169.                 err = GetTHPrintFromDescriptor(dataDesc, &theTHPrint);
  1170.                     
  1171.                 if (theTHPrint) 
  1172.                     {
  1173.                         if (theDocument->thePrintSetup) 
  1174.                             DisposHandle((Handle)theDocument->thePrintSetup);
  1175.                             
  1176.                         theDocument->thePrintSetup = theTHPrint;
  1177.                         
  1178.                         ResizePageSetupForDocument(theDocument);
  1179.                     }
  1180.                                 
  1181.             }
  1182.             
  1183.         if (theWindowPropToken.tokenProperty == pShowBorders) 
  1184.             {
  1185.                 err = GetBooleanFromDescriptor(dataDesc, &theBoolean);
  1186.                 theDocument->showBorders = theBoolean;
  1187.                 if (theBoolean)
  1188.                     DrawPageExtras(theDocument); /* Does the clipping as well as drawing borders/page breaks */
  1189.                 else
  1190.                     InvalidateDocument(theDocument);
  1191.             }
  1192.             
  1193.         if (theWindowPropToken.tokenProperty == pSelection) 
  1194.             {                    
  1195.                 err = AECoerceDesc(dataDesc, typeMyText, &tokenDesc);
  1196.                 
  1197.                 GetRawDataFromDescriptor(&tokenDesc,
  1198.                                                                  (Ptr)&myTextToken,
  1199.                                                                  sizeof(myTextToken),
  1200.                                                                  &tokenSize);
  1201.                                                                                  
  1202.                 ignoreErr = AEDisposeDesc(&tokenDesc);
  1203.                 
  1204.                 if (err == noErr) 
  1205.                     {
  1206.                         /* got a text token */
  1207.                         
  1208.                         theDocument = DPtrFromWindowPtr(myTextToken.tokenWindow);
  1209.                         theHTE      = theDocument->theText;
  1210.                         
  1211.                         TESetSelect(myTextToken.tokenOffset-1,
  1212.                                                 myTextToken.tokenOffset+myTextToken.tokenLength-1,
  1213.                                                 theHTE);
  1214.                     }
  1215.             }
  1216.             
  1217.         if ((theWindowPropToken.tokenProperty == pIndex)       ||
  1218.               (theWindowPropToken.tokenProperty == pIsModal)     ||
  1219.               (theWindowPropToken.tokenProperty == pIsResizable) ||
  1220.               (theWindowPropToken.tokenProperty == pHasTitleBar) ||
  1221.               (theWindowPropToken.tokenProperty == pHasCloseBox) ||
  1222.               (theWindowPropToken.tokenProperty == pIsFloating)  ||
  1223.               (theWindowPropToken.tokenProperty == pIsZoomable)  ||
  1224.                 (theWindowPropToken.tokenProperty == pIsModified))   
  1225.             err = errAEEventNotHandled; /* We don't allow these to be set */
  1226.         
  1227.         SetPort(oldPort);
  1228.         
  1229.         return(err);
  1230.                 
  1231.     } /* SetWindowProperty */
  1232.     
  1233. /* -----------------------------------------------------------------------
  1234.         Name:             AddDescStyleItem
  1235.         Purpose:        Adds the kAEXXXX style to theStyle.
  1236.      -----------------------------------------------------------------------**/
  1237.      
  1238. pascal void AddDescStyleItem(DescType theDesc, Style *theStyle)
  1239.     {
  1240.         if (theDesc == kAEBold)
  1241.             *theStyle = *theStyle+bold;
  1242.         else
  1243.         if (theDesc == kAEItalic)
  1244.             *theStyle = *theStyle+italic;
  1245.         else
  1246.         if (theDesc == kAEUnderline)
  1247.             *theStyle = *theStyle+underline;
  1248.         else
  1249.         if (theDesc == kAEOutline)
  1250.             *theStyle = *theStyle+outline;
  1251.         else
  1252.         if (theDesc == kAEShadow)
  1253.             *theStyle = *theStyle+shadow;
  1254.         else
  1255.         if (theDesc == kAECondensed)
  1256.             *theStyle = *theStyle+condense;
  1257.         else
  1258.         if (theDesc == kAEExpanded)
  1259.             *theStyle = *theStyle+extend;
  1260.         else
  1261.         if (theDesc == kAEPlain)
  1262.             *theStyle = 0;
  1263.     } /* AddDescStyleItem */
  1264.     
  1265. pascal OSErr MakeStyleFromAEList(const AEDescList *styleList, Style *theStyle, Boolean *hadPlain)
  1266.     {
  1267.         OSErr     myErr;
  1268.         DescType  styleDesc;
  1269.         long      itemsInList;
  1270.         long      actSize;
  1271.         AEKeyword keywd;
  1272.         DescType  typeCode;
  1273.             
  1274.         *hadPlain = false;
  1275.         *theStyle = 0;
  1276.         
  1277.       myErr = AECountItems(styleList, &itemsInList);
  1278.         while (itemsInList>0)
  1279.           if (myErr==noErr)
  1280.                 {
  1281.                     myErr  = AEGetNthPtr(styleList,
  1282.                                                              itemsInList,
  1283.                                                              typeEnumerated,
  1284.                                                              &keywd,
  1285.                                                              &typeCode,
  1286.                                                              (Ptr)&styleDesc,
  1287.                                                              sizeof(styleDesc),
  1288.                                                              &actSize);
  1289.                     
  1290.                     AddDescStyleItem(styleDesc, theStyle);
  1291.                     
  1292.                     if (styleDesc == kAEPlain) 
  1293.                       {
  1294.                             itemsInList = 0;
  1295.                             *hadPlain    = true;
  1296.                         }
  1297.                     else
  1298.                       itemsInList--;
  1299.                 }
  1300.                 
  1301.         return(myErr);
  1302.     } /*MakeStyleFromAEList*/
  1303.     
  1304. pascal OSErr GetTextStyles(const AEDesc *dataDesc, Style *onStyles, Style *offStyles)
  1305.     {
  1306.         OSErr      myErr;
  1307.         OSErr      ignoreErr;
  1308.         AEDescList textSDesc;
  1309.         AEDescList onDesc;
  1310.         AEDescList offDesc;
  1311.         Boolean    hadPlain;
  1312.             
  1313.       textSDesc.dataHandle = nil;
  1314.       onDesc.dataHandle    = nil;
  1315.       offDesc.dataHandle   = nil;
  1316.         
  1317.         *onStyles  = 0;
  1318.         *offStyles = 0;
  1319.         
  1320.       myErr = AECoerceDesc(dataDesc, typeAERecord, &textSDesc);
  1321.         
  1322.         if (myErr==noErr)
  1323.           myErr = AEGetKeyDesc(&textSDesc, keyAEOnStyles, typeAEList, &onDesc);
  1324.         
  1325.         if (myErr==noErr)
  1326.           myErr = AEGetKeyDesc(&textSDesc, keyAEOffStyles, typeAEList, &offDesc);
  1327.         
  1328.         if (myErr==noErr)
  1329.             myErr = MakeStyleFromAEList(&onDesc,  onStyles, &hadPlain);
  1330.         
  1331.         if (hadPlain)
  1332.             *offStyles = bold+italic+underline+outline+shadow+condense+extend;
  1333.         else
  1334.             {
  1335.                 if (myErr==noErr)
  1336.                     myErr = MakeStyleFromAEList(&offDesc, offStyles, &hadPlain);
  1337.                 
  1338.                 if (hadPlain)
  1339.                     myErr = errAEEventFailed;
  1340.             }
  1341.             
  1342.         if (textSDesc.dataHandle)
  1343.             ignoreErr = AEDisposeDesc(&textSDesc);
  1344.             
  1345.         if (onDesc.dataHandle)
  1346.             ignoreErr = AEDisposeDesc(&onDesc);
  1347.             
  1348.         if (offDesc.dataHandle)
  1349.             ignoreErr = AEDisposeDesc(&offDesc);
  1350.         
  1351.         return(myErr);
  1352.     } /* GetTextStyles */
  1353.  
  1354. /* -----------------------------------------------------------------------
  1355.         Name:             SetTextProperty
  1356.         Purpose:        Sets the text property specfied by theTextPropToken to
  1357.                                 that in dataDesc.
  1358.      -----------------------------------------------------------------------**/
  1359.      
  1360. pascal OSErr SetTextProperty(const AEDesc *tokenDesc, const AEDesc *dataDesc)
  1361.     {
  1362.       TEHandle      theHTE;
  1363.         DPtr          theDoc;
  1364.         Str255        name;
  1365.         short         theSize;
  1366.         OSErr         myErr;
  1367.         Style         onStyle;
  1368.         Style         offStyle;
  1369.         textPropToken theTextPropToken;
  1370.         AEDesc        newDesc;
  1371.         Size          tokenSize;
  1372.         
  1373.       newDesc.dataHandle = nil;
  1374.         
  1375.       myErr = AECoerceDesc(tokenDesc, typeMyTextProp, &newDesc);
  1376.         if (myErr == noErr)
  1377.             {
  1378.                 GetRawDataFromDescriptor(&newDesc,
  1379.                                                                  (Ptr)&theTextPropToken,
  1380.                                                                  sizeof(theTextPropToken),
  1381.                                                                  &tokenSize);
  1382.                 myErr = AEDisposeDesc(&newDesc);
  1383.             }
  1384.         else
  1385.             return(myErr);
  1386.             
  1387.         theDoc = DPtrFromWindowPtr(theTextPropToken.propertyTextToken.tokenWindow);
  1388.         theDoc->dirty = true;
  1389.         
  1390.         if (theTextPropToken.propertyProperty == pText) 
  1391.             {
  1392.                 theHTE = theDoc->theText;
  1393.                 TESetSelect(theTextPropToken.propertyTextToken.tokenOffset-1,
  1394.                                         theTextPropToken.propertyTextToken.tokenOffset+
  1395.                                                                 theTextPropToken.propertyTextToken.tokenLength-1,
  1396.                                         theHTE);
  1397.                 
  1398.                 DoTEDeleteSectionRecalc(theDoc);
  1399.                 TEDelete(theHTE);
  1400.                 
  1401.                 myErr = GetStyledTextFromDescIntoTEHandle(dataDesc, theHTE);
  1402.  
  1403.                 return(myErr);
  1404.             }
  1405.             
  1406.         if (theTextPropToken.propertyProperty == pFont) 
  1407.             {                    
  1408.                 myErr = GetPStringFromDescriptor(dataDesc, (char *)name);
  1409.                 
  1410.                 SetTheFontOfTheTokenText(theTextPropToken.propertyTextToken,
  1411.                                                                  name);
  1412.                 
  1413.                 return(noErr);
  1414.             }
  1415.             
  1416.         if (theTextPropToken.propertyProperty == pPointSize) 
  1417.             {
  1418.                 myErr = GetIntegerFromDescriptor(dataDesc, &theSize);
  1419.                 SetTheSizeOfTheTokenText(theTextPropToken.propertyTextToken,
  1420.                                                                  theSize);
  1421.                 
  1422.                 return(noErr);
  1423.             }
  1424.             
  1425.         if (theTextPropToken.propertyProperty == pTextStyles) 
  1426.             {
  1427.                 onStyle  = 0;
  1428.                 offStyle = 0;
  1429.                 
  1430.                 myErr = GetTextStyles(dataDesc, &onStyle, &offStyle);
  1431.  
  1432.         if (onStyle & offStyle != 0)
  1433.                     myErr = errAEEventFailed;
  1434.                 else
  1435.                     SetTheStyleOfTheTokenText(&theTextPropToken.propertyTextToken,
  1436.                                                                         onStyle,
  1437.                                                                         offStyle);
  1438.                 
  1439.                 return(myErr);
  1440.             }
  1441.                         
  1442.         return(errAEWrongDataType);
  1443.             
  1444.     } /* SetTextProperty */
  1445.     
  1446. /* -----------------------------------------------------------------------
  1447.         Name:             HandleSetData
  1448.         Purpose:        Resolves the object into a token (could be one of many) and
  1449.                                 the sets the data of that object to dataDesc.
  1450.      -----------------------------------------------------------------------**/
  1451.      
  1452. pascal OSErr HandleSetData(const AEDesc *theObj, const AEDesc *dataDesc)
  1453. {
  1454.   OSErr           myErr;
  1455.     AEDesc          newDesc;
  1456.     DPtr            theDocument;
  1457.     TEHandle        theHTE;
  1458.     TextToken       theTextToken;
  1459.     Size            tokenSize;
  1460.     AEDesc          objTokenDesc;
  1461.     OSErr           ignoreErr;
  1462.     
  1463.     objTokenDesc.dataHandle = nil;
  1464.     newDesc.dataHandle      = nil;
  1465.     
  1466.     /*
  1467.         Coerce theObj into a token which we can use - 
  1468.              set the property or data for that token
  1469.     */
  1470.     
  1471.     myErr = AEResolve(theObj ,kAEIDoMinimum, &objTokenDesc);
  1472.         
  1473.     /* We don't actually allow ANY app property setting, but
  1474.        just incase we'll decode looking for an typeMyApplProp and flag an error -
  1475.          do same for menu related tokens
  1476.     */
  1477.     
  1478.     if ((objTokenDesc.descriptorType == typeMyApplProp) ||
  1479.             (objTokenDesc.descriptorType == typeMyMenu    ) ||
  1480.             (objTokenDesc.descriptorType == typeMyMenuProp) ||
  1481.             (objTokenDesc.descriptorType == typeMyMenuItem) ||
  1482.             (objTokenDesc.descriptorType == typeMyItemProp))
  1483.         myErr = errAEWrongDataType;
  1484.     else
  1485.     
  1486.     if (objTokenDesc.descriptorType == typeMyWindowProp)
  1487.         myErr = SetWindowProperty(&objTokenDesc, dataDesc);
  1488.     else
  1489.     
  1490.     if (objTokenDesc.descriptorType == typeMyTextProp)
  1491.         myErr = SetTextProperty(&objTokenDesc, dataDesc);
  1492.     else
  1493.  
  1494.     if (objTokenDesc.descriptorType == typeMyText)
  1495.       if (AECoerceDesc(&objTokenDesc, typeMyText, &newDesc) == noErr) 
  1496.             {
  1497.                 GetRawDataFromDescriptor(&newDesc,
  1498.                                                                  (Ptr)&theTextToken,
  1499.                                                                  sizeof(theTextToken),
  1500.                                                                  &tokenSize);
  1501.                                                                  
  1502.                 myErr = AEDisposeDesc(&newDesc);
  1503.                                                                  
  1504.                 theDocument = DPtrFromWindowPtr(theTextToken.tokenWindow);
  1505.                 theHTE            = theDocument->theText;
  1506.                 
  1507.                 TESetSelect(theTextToken.tokenOffset-1,
  1508.                                         theTextToken.tokenOffset+
  1509.                                                                 theTextToken.tokenLength-1,
  1510.                                         theHTE);
  1511.                 
  1512.                 DoTEDeleteSectionRecalc(theDocument);
  1513.                 TEDelete(theHTE);
  1514.                 
  1515.                 myErr = GetStyledTextFromDescIntoTEHandle(dataDesc, theHTE);
  1516.                 
  1517.                 theDocument->dirty = true;
  1518.             }
  1519.         
  1520.     ignoreErr = AEDisposeDesc(&objTokenDesc);
  1521.  
  1522.     return(myErr);
  1523. }    /* HandleSetData */
  1524.  
  1525. /*
  1526.     A few convenient FORWARDS...
  1527. */
  1528.  
  1529. pascal OSErr MakeWindowObj( WindowPtr theWindow, AEDesc *dMyDoc);
  1530.  
  1531. /*
  1532.     Back to real code
  1533. */
  1534. pascal OSErr MakeSelTextObj( WindowPtr theWindow,
  1535.                                                          TEHandle  theTextEditHandle,
  1536.                                                          AEDesc    *selTextObj)
  1537. /*
  1538.     This is a hack to get the AppleScript Alpha to work...
  1539. */
  1540.     {
  1541.         OSErr    myErr;
  1542.         OSErr    ignoreErr;
  1543.         AEDesc   dNull;
  1544.         AEDesc   dMyDoc;
  1545.         AEDesc   startOfs;
  1546.         AEDesc   endOfs;
  1547.         AEDesc   startObj;
  1548.         AEDesc   endObj;
  1549.         AEDesc   rangeDesc;
  1550.         long     startChar;
  1551.         long     endChar;
  1552.         Boolean  spotFlag;
  1553.             
  1554.         myErr = noErr;
  1555.         
  1556.         if (theWindow==nil) 
  1557.             return(noErr);
  1558.             
  1559.         selTextObj->dataHandle = nil;
  1560.         dMyDoc.dataHandle      = nil;
  1561.         startObj.dataHandle    = nil;
  1562.         endObj.dataHandle      = nil;
  1563.         
  1564.         /* 
  1565.             make the window object 
  1566.         */
  1567.         
  1568.         myErr = MakeWindowObj(theWindow, &dMyDoc);
  1569.             
  1570.         if (myErr==noErr)
  1571.             {
  1572.                 /* get the start and end of selection */
  1573.                 
  1574.                 startChar = (*theTextEditHandle)->selStart+1;    /* start counting obj's from 1, not 0 */
  1575.                 endChar   = (*theTextEditHandle)->selEnd;
  1576.                 spotFlag  = ((*theTextEditHandle)->selStart == (*theTextEditHandle)->selEnd);
  1577.                     
  1578.                 myErr = CreateOffsetDescriptor(startChar, &startOfs);
  1579.                             
  1580.                 if (myErr==noErr)
  1581.                     if (spotFlag)
  1582.                         myErr = CreateObjSpecifier(cSpot,
  1583.                                                                              &dMyDoc,
  1584.                                                                              formAbsolutePosition, 
  1585.                                                                              &startOfs, 
  1586.                                                                              true, 
  1587.                                                                              selTextObj);
  1588.                     else
  1589.                         {
  1590.                             /* not a spot - must represent as range */
  1591.                             /* make obj for start char */
  1592.                             
  1593.                             myErr = AECreateDesc(typeNull, nil , 0, &dNull);
  1594.                             
  1595.                             myErr = CreateObjSpecifier(cChar,
  1596.                                                        &dNull,
  1597.                                                                                  formAbsolutePosition,
  1598.                                                                                  &startOfs,
  1599.                                                                                  false,
  1600.                                                                                  &startObj);
  1601.                             
  1602.                             if (myErr==noErr) 
  1603.                                 myErr = CreateOffsetDescriptor(endChar, &endOfs);
  1604.                             
  1605.                             if (myErr==noErr) 
  1606.                                 myErr = CreateObjSpecifier(cChar,
  1607.                                                                                      &dNull,
  1608.                                                                                      formAbsolutePosition,
  1609.                                                                                      &endOfs,
  1610.                                                                                      false,
  1611.                                                                                      &endObj);
  1612.                             
  1613.                             if (myErr==noErr) 
  1614.                                 myErr = CreateRangeDescriptor(&startObj,
  1615.                                                                                             &endObj,
  1616.                                                                                             false,
  1617.                                                                                             &rangeDesc);
  1618.                             
  1619.                             if (myErr==noErr) 
  1620.                                 myErr = CreateObjSpecifier(cChar,
  1621.                                                                                      &dMyDoc,
  1622.                                                                                      formRange,
  1623.                                                                                      &rangeDesc,
  1624.                                                                                      true,
  1625.                                                                                      selTextObj);
  1626.                                                                                      
  1627.                             if (startObj.dataHandle)
  1628.                               ignoreErr = AEDisposeDesc(&startObj);
  1629.                                 
  1630.                             if (startOfs.dataHandle)
  1631.                               ignoreErr = AEDisposeDesc(&startOfs);
  1632.                                 
  1633.                             if (endObj.dataHandle)
  1634.                               ignoreErr = AEDisposeDesc(&endObj);
  1635.                                 
  1636.                             if (endOfs.dataHandle)
  1637.                               ignoreErr = AEDisposeDesc(&endOfs);
  1638.                         }
  1639.             }
  1640.             
  1641.         return(myErr);
  1642.     }    /* MakeSelTextObj */
  1643.  
  1644. /* -----------------------------------------------------------------------
  1645.         Name:             DoSetData
  1646.         Purpose:        Handles the SetData Apple Event, extracting the direct
  1647.                                 object (which says what to set) and the data (what to set
  1648.                                 it to).
  1649.      -----------------------------------------------------------------------**/
  1650.      
  1651. pascal OSErr DoSetData(const AppleEvent *theAppleEvent,
  1652.                                                AppleEvent *reply,
  1653.                                                          long        handlerRefCon)
  1654.   {
  1655. #pragma unused (reply, handlerRefCon)
  1656.     
  1657.         OSErr  myErr;
  1658.         OSErr  ignoreErr;
  1659.         AEDesc myDirObj;
  1660.         AEDesc myDataDesc;
  1661.         
  1662.         myDataDesc.dataHandle = nil;
  1663.         myDirObj.dataHandle   = nil;
  1664.                 
  1665.         /* pick up the direct object, which is the object whose data is to be set */
  1666.         
  1667.         myErr = AEGetParamDesc(theAppleEvent,
  1668.                                                      keyDirectObject,
  1669.                                                      typeWildCard,
  1670.                                                      &myDirObj);
  1671.             
  1672.         /* now the data to set it to - typeWildCard means get as is*/
  1673.         if (myErr == noErr) 
  1674.             myErr = AEGetParamDesc( theAppleEvent,
  1675.                                                             keyAEData,
  1676.                                                             typeWildCard,
  1677.                                                             &myDataDesc);
  1678.         
  1679.         /* missing any parameters? */
  1680.         if (myErr == noErr) 
  1681.             myErr = GotRequiredParams(theAppleEvent);
  1682.         
  1683.         /* set the data */
  1684.         if (myErr == noErr) 
  1685.             myErr = HandleSetData(&myDirObj, &myDataDesc);
  1686.             
  1687.         if (myDataDesc.dataHandle)
  1688.             ignoreErr = AEDisposeDesc(&myDataDesc);
  1689.             
  1690.         if (myDirObj.dataHandle)
  1691.             ignoreErr = AEDisposeDesc(&myDirObj);
  1692.   
  1693.         return(myErr);
  1694.     }    /* DoSetData */
  1695.     
  1696. pascal void StyleTokConst(short theStyleItem, DescType *thekConst)
  1697.     {
  1698.         switch (theStyleItem) {
  1699.           case bold      : *thekConst = kAEBold;
  1700.                                              break;
  1701.       case italic    : *thekConst = kAEItalic;
  1702.                                              break;
  1703.       case underline : *thekConst = kAEUnderline;
  1704.                                              break;
  1705.       case outline   : *thekConst = kAEOutline;
  1706.                                              break;
  1707.             case shadow    : *thekConst = kAEShadow;
  1708.                                              break;
  1709.             case condense  : *thekConst = kAECondensed;
  1710.                                              break;
  1711.             case extend    : *thekConst = kAEExpanded;
  1712.                                              break;
  1713.         }
  1714.     } /*StyleTokConst*/
  1715.  
  1716. pascal OSErr BuildTypeTextStylesDesc(Style onStyles, Style offStyles, AEDesc *resultDesc)
  1717.     {
  1718.  
  1719.         OSErr     myErr;
  1720.         OSErr     ignoreErr;
  1721.         short     myStyleItem;
  1722.         DescType  styleConst;
  1723.         AEDesc    onStylesDesc;
  1724.         AEDesc    offStylesDesc;
  1725.         AEDesc    dataDesc;
  1726.         
  1727.         onStylesDesc.dataHandle  = nil;
  1728.         offStylesDesc.dataHandle = nil;
  1729.         dataDesc.dataHandle  = nil;
  1730.     
  1731.         myErr = AECreateList(nil, 0, true,  &dataDesc);
  1732.         
  1733.         myErr = AECreateList(nil, 0, false, &onStylesDesc);
  1734.         myErr = AECreateList(nil, 0, false, &offStylesDesc);
  1735.         
  1736.         for (myStyleItem = bold; myStyleItem<=extend; myStyleItem = myStyleItem <<1)
  1737.             if (myErr==noErr)
  1738.                 {
  1739.                     StyleTokConst(myStyleItem, &styleConst);
  1740.                     if (myStyleItem & onStyles)
  1741.                         myErr  = AEPutPtr(&onStylesDesc,
  1742.                                                             0,                /*add to end of list*/
  1743.                                                             typeEnumerated, /* text for style name */
  1744.                                                             (Ptr)&styleConst,
  1745.                                                             sizeof(styleConst));
  1746.                     
  1747.                     if (myStyleItem & offStyles)
  1748.                         myErr  = AEPutPtr(&offStylesDesc,
  1749.                                                             0,                /*add to end of list*/
  1750.                                                             typeEnumerated, /* text for style name */
  1751.                                                             (Ptr)&styleConst,
  1752.                                                             sizeof(styleConst));
  1753.             }
  1754.         
  1755.         if (myErr==noErr)
  1756.             myErr = AEPutKeyDesc(&dataDesc, keyAEOnStyles,  &onStylesDesc);
  1757.         
  1758.         if (myErr==noErr)
  1759.             myErr = AEPutKeyDesc(&dataDesc, keyAEOffStyles, &offStylesDesc);
  1760.         
  1761.         if (myErr==noErr)
  1762.             myErr = AECoerceDesc(&dataDesc, typeTextStyles, resultDesc);
  1763.             
  1764.         if (onStylesDesc.dataHandle)
  1765.             ignoreErr = AEDisposeDesc(&onStylesDesc);
  1766.             
  1767.         if (offStylesDesc.dataHandle)
  1768.             ignoreErr = AEDisposeDesc(&offStylesDesc);
  1769.             
  1770.         if (dataDesc.dataHandle)
  1771.             ignoreErr = AEDisposeDesc(&dataDesc);
  1772.     
  1773.         return(myErr);
  1774.     }
  1775.  
  1776. pascal OSErr BuildTextStylesDesc(Style theStyle, AEDesc *resultDesc)
  1777.     {
  1778.         short     myStyleItem;
  1779.         Style     onStyles;
  1780.         Style     offStyles;
  1781.                 
  1782.         onStyles  = 0;
  1783.         offStyles = 0;
  1784.         
  1785.         for (myStyleItem = bold; myStyleItem<=extend; myStyleItem = myStyleItem <<1)
  1786.             {
  1787.                 if (myStyleItem & theStyle)
  1788.                     onStyles  = onStyles  + myStyleItem;
  1789.                 else
  1790.                     offStyles = offStyles + myStyleItem;
  1791.             }
  1792.     
  1793.         return(BuildTypeTextStylesDesc(onStyles, offStyles, resultDesc));
  1794.         
  1795.     } /* BuildTextStylesDesc */
  1796.         
  1797. pascal OSErr BuildStyledTextDesc(TEHandle theHTE, short start, short howLong, AEDesc *resultDesc)
  1798.     {
  1799.         AEDesc       listDesc;
  1800.         short        oldSelStart;
  1801.         short        oldSelEnd;
  1802.         StScrpHandle myStScrpHandle;
  1803.         OSErr        myErr;
  1804.         OSErr        ignoreErr;
  1805.         
  1806.         listDesc.dataHandle = nil;
  1807.         
  1808.         oldSelStart = (**theHTE).selStart;
  1809.         oldSelEnd   = (**theHTE).selEnd;
  1810.         
  1811.         TESetSelect(start-1, start+howLong-2, theHTE);
  1812.         
  1813.         myErr = AECreateList(nil, 0, true,  &listDesc);
  1814.         
  1815.         HLock((Handle)(**theHTE).hText);
  1816.                                                          
  1817.         if (myErr==noErr)
  1818.             myErr = AEPutKeyPtr(&listDesc,
  1819.                                 keyAEText,
  1820.                                                     typeChar,
  1821.                                                     (Ptr)&(*(**theHTE).hText)[start-1],
  1822.                                                     howLong);
  1823.                                                     
  1824.         HUnlock((Handle)(**theHTE).hText);
  1825.         
  1826.         myStScrpHandle = GetStylScrap(theHTE);
  1827.         
  1828.         if (myStScrpHandle)
  1829.             {
  1830.                 HLock((Handle)myStScrpHandle);
  1831.                 
  1832.                 if (myErr==noErr)
  1833.                     myErr = AEPutKeyPtr(&listDesc,
  1834.                                         keyAEStyles,
  1835.                                                             typeScrapStyles,
  1836.                                                             (Ptr)*myStScrpHandle,
  1837.                                                             GetHandleSize((Handle)myStScrpHandle));
  1838.                     
  1839.                 HUnlock((Handle)myStScrpHandle);
  1840.             }    
  1841.         else
  1842.             myErr = AEPutKeyPtr(&listDesc,
  1843.                                                     keyAEStyles,
  1844.                                                     typeScrapStyles,
  1845.                                                     (Ptr)nil,
  1846.                                                     0);
  1847.         
  1848.         if (myErr==noErr)
  1849.             myErr = AECoerceDesc(&listDesc, typeStyledText, resultDesc); // should be typeIntlText
  1850.         
  1851.         if (listDesc.dataHandle)
  1852.             ignoreErr = AEDisposeDesc(&listDesc);
  1853.         
  1854.         TESetSelect(oldSelStart, oldSelEnd, theHTE);
  1855.         
  1856.         return(myErr);
  1857.     }
  1858.         
  1859. /* -----------------------------------------------------------------------
  1860.         Name:             GetTextProperty
  1861.         Purpose:        Fills dataDesc with the requested text property.
  1862.      -----------------------------------------------------------------------**/
  1863.      
  1864. pascal OSErr GetTextProperty(const AEDesc *theTokenDesc, AEDesc *dataDesc)
  1865.     {
  1866.       DPtr          theDocument;
  1867.         TEHandle      theHTE;
  1868.         Str255        fontName;
  1869.         short         theSize;
  1870.         GrafPtr       oldPort;
  1871.         TextStyle     theTextStyle;
  1872.         short         lineHeight;
  1873.         short         fontAscent;
  1874.         textPropToken theTextPropToken;
  1875.         OSErr         myErr;
  1876.         Size          tokenSize;
  1877.         AEDesc        newDesc;
  1878.         
  1879.       myErr = AECoerceDesc(theTokenDesc, typeMyTextProp, &newDesc);
  1880.         if (myErr == noErr)
  1881.             {
  1882.                 GetRawDataFromDescriptor(&newDesc,
  1883.                                                                  (Ptr)&theTextPropToken,
  1884.                                                                  sizeof(theTextPropToken),
  1885.                                                                  &tokenSize);
  1886.                 myErr= AEDisposeDesc(&newDesc);                                                 
  1887.             }
  1888.         else
  1889.           return(myErr);
  1890.  
  1891.         /*
  1892.             For each property we build a descriptor to be returned as the reply.
  1893.         */
  1894.                 
  1895.         theDocument = DPtrFromWindowPtr(theTextPropToken.propertyTextToken.tokenWindow);
  1896.         theHTE             = theDocument->theText;
  1897.         
  1898.         TEGetStyle (theTextPropToken.propertyTextToken.tokenOffset-1,
  1899.                                 &theTextStyle,
  1900.                                 &lineHeight,
  1901.                                 &fontAscent,
  1902.                                 theHTE);
  1903.                                         
  1904.         if (theTextPropToken.propertyProperty == pText) 
  1905.             {
  1906.                 myErr = BuildStyledTextDesc(theHTE,
  1907.                                                                         theTextPropToken.propertyTextToken.tokenOffset,
  1908.                                                                         theTextPropToken.propertyTextToken.tokenLength,
  1909.                                                                         dataDesc);
  1910.             }
  1911.         else
  1912.         if (theTextPropToken.propertyProperty == pFont) 
  1913.             {
  1914.             
  1915.                 GetFontName(theTextStyle.tsFont, fontName);
  1916.                 
  1917.                 myErr = AECreateDesc(typeChar,
  1918.                                                          (Ptr)&fontName[1],
  1919.                                                          fontName[0],
  1920.                                                          dataDesc);
  1921.             }
  1922.             
  1923.         else
  1924.         if (theTextPropToken.propertyProperty == pTextStyles) 
  1925.             myErr = BuildTextStylesDesc(theTextStyle.tsFace, dataDesc);
  1926.  
  1927.         else
  1928.         if (theTextPropToken.propertyProperty == pPointSize) 
  1929.             myErr =CreateOffsetDescriptor(theTextStyle.tsSize, dataDesc);
  1930.  
  1931.         else
  1932.         if (theTextPropToken.propertyProperty == pScriptTag) 
  1933.             myErr = CreateOffsetDescriptor(smSystemScript, dataDesc);
  1934.         else
  1935.         if (theTextPropToken.propertyProperty == pStringWidth) 
  1936.             {
  1937.                 GetPort(&oldPort);
  1938.                 SetPort(theTextPropToken.propertyTextToken.tokenWindow);
  1939.                 
  1940.                 HLock((Handle)(*theHTE)->hText);
  1941.                 theSize = TextWidth(&(*theHTE)->hText,
  1942.                                                         theTextPropToken.propertyTextToken.tokenOffset-1,
  1943.                                                         theTextPropToken.propertyTextToken.tokenLength);
  1944.                 
  1945.                 HUnlock((Handle)(*theHTE)->hText);
  1946.                 
  1947.                 SetPort(oldPort);
  1948.                 return(CreateOffsetDescriptor(theSize, dataDesc));
  1949.             }
  1950.             
  1951.         else
  1952.         if (theTextPropToken.propertyProperty == pColor) 
  1953.             myErr = AECreateDesc(typeRGBColor,
  1954.                                                      (Ptr)&theTextStyle.tsColor,
  1955.                                                      sizeof(theTextStyle.tsColor),
  1956.                                                      dataDesc);
  1957.         else
  1958.             myErr = errAEEventNotHandled;
  1959.             
  1960.         return(myErr);
  1961.         
  1962.     } /*GetTextProperty*/
  1963.     
  1964. /* -----------------------------------------------------------------------
  1965.         Name:             GetWindowProperty
  1966.         Purpose:        Fills dataDesc with the requested window property.
  1967.      -----------------------------------------------------------------------**/
  1968. typedef Rect **RectHandle;
  1969.  
  1970. pascal OSErr GetWindowProperty(const AEDesc *theWPTokenObj, AEDesc *dataDesc)
  1971.   {             
  1972.     OSErr           theErr;
  1973.         Str255          theName;
  1974.         Boolean         theBoolean;
  1975.         Rect            theRect;
  1976.         Point           thePoint;
  1977.         Rect            winRect;
  1978.         Rect            userRect;
  1979.         short           theIndex;
  1980.         DPtr            theDocument;
  1981.         TEHandle        theHTE;
  1982.         windowPropToken theWindowPropToken;
  1983.         AEDesc          newDesc;
  1984.         Size            tokenSize;
  1985.         
  1986.       theErr = AECoerceDesc(theWPTokenObj,typeMyWindowProp, &newDesc);
  1987.         
  1988.         if (theErr == noErr)
  1989.             {
  1990.                 GetRawDataFromDescriptor(&newDesc,
  1991.                                                                  (Ptr)&theWindowPropToken,
  1992.                                                                  sizeof(theWindowPropToken),
  1993.                                                                  &tokenSize);
  1994.                                                                  
  1995.                 theErr = AEDisposeDesc(&newDesc);
  1996.             }
  1997.         else
  1998.           return(theErr);
  1999.             
  2000.         theErr = kAEGenericErr;
  2001.         
  2002.         if (theWindowPropToken.tokenProperty == pName) 
  2003.             {
  2004.                 GetWTitle(theWindowPropToken.tokenWindowToken, theName);
  2005.                 theErr = AECreateDesc(typeChar,
  2006.                                                             (Ptr)&theName[1],
  2007.                                                             theName[0],
  2008.                                                             dataDesc);
  2009.             }
  2010.             
  2011.         if (theWindowPropToken.tokenProperty == pText) 
  2012.             {
  2013.                 theDocument = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  2014.                 theHTE      = theDocument->theText;
  2015.                 
  2016.                 theErr = BuildStyledTextDesc(theHTE,
  2017.                                                                          1,
  2018.                                                                          (**theHTE).teLength,
  2019.                                                                          dataDesc);
  2020.             }
  2021.             
  2022.         if (theWindowPropToken.tokenProperty == pBounds) 
  2023.             {
  2024.                 SetPort(theWindowPropToken.tokenWindowToken);
  2025.                 
  2026.                 theRect = (*((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn)->rgnBBox;
  2027.                 
  2028.                 theErr  = AECreateDesc(typeQDRectangle,
  2029.                                                              (Ptr)&theRect,
  2030.                                                              sizeof(theRect),
  2031.                                                              dataDesc);
  2032.             }
  2033.             
  2034.         if (theWindowPropToken.tokenProperty == pPosition) 
  2035.             {
  2036.                 thePoint.v = (*((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn)->rgnBBox.top;
  2037.                 thePoint.h = (*((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn)->rgnBBox.left;
  2038.                             
  2039.                 theErr   = AECreateDesc(typeQDPoint,
  2040.                                                               (Ptr)&thePoint,
  2041.                                                               sizeof(thePoint),
  2042.                                                               dataDesc);
  2043.             }
  2044.                         
  2045.         if (theWindowPropToken.tokenProperty == pVisible) 
  2046.             {
  2047.                 theBoolean = ((WindowPeek)theWindowPropToken.tokenWindowToken)->visible;
  2048.                                 
  2049.                 theErr  = AECreateDesc(typeBoolean,
  2050.                                                              (Ptr)&theBoolean,
  2051.                                                              sizeof(theBoolean),
  2052.                                                              dataDesc);
  2053.             }
  2054.             
  2055.         if (theWindowPropToken.tokenProperty == pIsModal) 
  2056.             {
  2057.                 theBoolean = false;
  2058.                                 
  2059.                 theErr  = AECreateDesc(typeBoolean,
  2060.                                                              (Ptr)&theBoolean,
  2061.                                                              sizeof(theBoolean),
  2062.                                                              dataDesc);
  2063.             }
  2064.             
  2065.         if (theWindowPropToken.tokenProperty == pShowBorders) 
  2066.             {
  2067.                 theDocument  = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  2068.                 theBoolean   = theDocument->showBorders;
  2069.                                 
  2070.                 theErr  = AECreateDesc(typeBoolean,
  2071.                                                              (Ptr)&theBoolean,
  2072.                                                              sizeof(theBoolean),
  2073.                                                              dataDesc);
  2074.             }
  2075.             
  2076.         if (theWindowPropToken.tokenProperty == pIsZoomed) 
  2077.             {
  2078.                 if (((WindowPeek)theWindowPropToken.tokenWindowToken)->spareFlag) 
  2079.                     {
  2080.                         SetPort(theWindowPropToken.tokenWindowToken);
  2081.                         
  2082.                         userRect = **((RectHandle)((WindowPeek)qd.thePort)->dataHandle);
  2083.                         winRect  = qd.thePort->portRect;
  2084.                         LocalToGlobal((Point *)&winRect.top);
  2085.                         LocalToGlobal((Point *)&winRect.bottom);
  2086.                         
  2087.                         theBoolean = !EqualRect(&userRect, &winRect);
  2088.                     }
  2089.                 else
  2090.                     theBoolean = false;
  2091.                                 
  2092.                 theErr  = AECreateDesc(typeBoolean,
  2093.                                                              (Ptr)&theBoolean,
  2094.                                                              sizeof(theBoolean),
  2095.                                                              dataDesc);
  2096.             }
  2097.             
  2098.         if ((theWindowPropToken.tokenProperty == pIsResizable) ||
  2099.             (theWindowPropToken.tokenProperty == pHasTitleBar) ||
  2100.             (theWindowPropToken.tokenProperty == pHasCloseBox) ||
  2101.                 (theWindowPropToken.tokenProperty == pIsZoomable))
  2102.             {
  2103.                 theBoolean = true;
  2104.                                 
  2105.                 theErr  = AECreateDesc(typeBoolean,
  2106.                                                              (Ptr)&theBoolean,
  2107.                                                              sizeof(theBoolean),
  2108.                                                              dataDesc);
  2109.             }
  2110.         
  2111.         if (theWindowPropToken.tokenProperty == pIsFloating) 
  2112.             {
  2113.                 theBoolean = false;
  2114.                                 
  2115.                 theErr  = AECreateDesc(typeBoolean,
  2116.                                                              (Ptr)&theBoolean,
  2117.                                                              sizeof(theBoolean),
  2118.                                                              dataDesc);
  2119.             }
  2120.             
  2121.         if (theWindowPropToken.tokenProperty == pIsModified)
  2122.             {
  2123.                 theDocument = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  2124.                 
  2125.                 theBoolean  = theDocument->dirty;
  2126.                 
  2127.                 theErr  = AECreateDesc(typeBoolean,
  2128.                                                              (Ptr)&theBoolean,
  2129.                                                              sizeof(theBoolean),
  2130.                                                              dataDesc);
  2131.             }
  2132.             
  2133.         if (theWindowPropToken.tokenProperty == pIndex) 
  2134.             {
  2135.                 theIndex = 0;
  2136.                 if (theWindowPropToken.tokenWindowToken) 
  2137.                     do
  2138.                         theIndex++;
  2139.                     while (theWindowPropToken.tokenWindowToken != GetWindowPtrOfNthWindow(theIndex));
  2140.                                 
  2141.                 theErr  = AECreateDesc(typeShortInteger,
  2142.                                                              (Ptr)theIndex,
  2143.                                                              sizeof(theIndex),
  2144.                                                              dataDesc);
  2145.             }
  2146.             
  2147.         if (theWindowPropToken.tokenProperty == pPageSetup) 
  2148.             {
  2149.                 theDocument = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  2150.                 
  2151.                 HLock((Handle)theDocument->thePrintSetup);
  2152.                 
  2153.                 theErr  = AECreateDesc(typeTPrint,
  2154.                                                              (Ptr)*(theDocument->thePrintSetup),
  2155.                                                              sizeof(TPrint),
  2156.                                                              dataDesc);
  2157.                                                              
  2158.                 HUnlock((Handle)theDocument->thePrintSetup);
  2159.                                                              
  2160.             }
  2161.             
  2162.         if (theWindowPropToken.tokenProperty == pSelection) 
  2163.             {
  2164.                 theDocument = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  2165.                 
  2166.                 theErr  = MakeSelTextObj( theWindowPropToken.tokenWindowToken,
  2167.                                                                     theDocument->theText, 
  2168.                                                                     dataDesc);                                                             
  2169.             }
  2170.             
  2171.         return(theErr);
  2172.     } /* GetWindowProperty */
  2173.     
  2174. /** -----------------------------------------------------------------------
  2175.         Name:             GetApplicationProperty
  2176.         Purpose:        Fills dataDesc with the requested application property.
  2177.      -----------------------------------------------------------------------**/
  2178.      
  2179. pascal OSErr GetApplicationProperty(const AEDesc *theObjToken, AEDesc *dataDesc)
  2180.     {
  2181.       OSErr         theErr;
  2182.         Str255        theName;
  2183.         Boolean       isFront;
  2184.         applPropToken theApplPropToken;
  2185.         AEDesc        newDesc;
  2186.         Size          tokenSize;
  2187.         
  2188.         theErr = AECoerceDesc(theObjToken, typeMyApplProp, &newDesc);
  2189.         if (theErr==noErr)
  2190.             {
  2191.                 GetRawDataFromDescriptor(&newDesc,
  2192.                                                                  (Ptr)&theApplPropToken,
  2193.                                                                  sizeof(theApplPropToken),
  2194.                                                                  &tokenSize);
  2195.                                                                  
  2196.                 theErr = AEDisposeDesc(&newDesc);
  2197.             }
  2198.         else
  2199.           return(theErr);
  2200.  
  2201.         theErr = kAEGenericErr;
  2202.         
  2203.         if (theApplPropToken.tokenApplProperty == pName) 
  2204.             {
  2205.                 PLstrcpy((StringPtr)theName, (unsigned char *)"\p7Edit");
  2206.                 theErr  = AECreateDesc(typeChar,
  2207.                                                              (Ptr)&theName[1],
  2208.                                                              theName[0],
  2209.                                                              dataDesc);
  2210.             }
  2211.         
  2212.         if (theApplPropToken.tokenApplProperty == pVersion) 
  2213.             {
  2214.                 PLstrcpy((StringPtr)theName, (unsigned char *)"\p3.0d5");
  2215.                 theErr  = AECreateDesc(typeChar,
  2216.                                                              (Ptr)&theName[1],
  2217.                                                              theName[0],
  2218.                                                              dataDesc);
  2219.             }
  2220.         
  2221.         if (theApplPropToken.tokenApplProperty == pIsFrontProcess) 
  2222.             {
  2223.                 isFront = !gInBackground;
  2224.                 theErr  = AECreateDesc(typeBoolean,
  2225.                                                              (Ptr)&isFront,
  2226.                                                              sizeof(isFront),
  2227.                                                              dataDesc);
  2228.             }
  2229.             
  2230.         return(theErr);
  2231.     } /* GetApplicationProperty */
  2232.  
  2233. /** -----------------------------------------------------------------------
  2234.         Name:             GetMenuProperty
  2235.         Purpose:        Fills dataDesc with the requested menu property.
  2236.      -----------------------------------------------------------------------**/
  2237.      
  2238. pascal OSErr GetMenuProperty(const AEDesc *theObjToken, AEDesc *dataDesc)
  2239.     {
  2240.       OSErr         theErr;
  2241.         Str255        theName;
  2242.         MenuPropToken theMenuPropToken;
  2243.         AEDesc        newDesc;
  2244.         Size          tokenSize;
  2245.         
  2246.         theErr = AECoerceDesc(theObjToken, typeMyMenuProp, &newDesc);
  2247.         if (theErr==noErr)
  2248.             {
  2249.                 GetRawDataFromDescriptor(&newDesc,
  2250.                                                                  (Ptr)&theMenuPropToken,
  2251.                                                                  sizeof(theMenuPropToken),
  2252.                                                                  &tokenSize);
  2253.                                                                  
  2254.                 theErr = AEDisposeDesc(&newDesc);
  2255.             }
  2256.         else
  2257.           return(theErr);
  2258.  
  2259.         theErr = kAEGenericErr;
  2260.         
  2261.         if (theMenuPropToken.theMenuProp == pName) 
  2262.             {
  2263.               PLstrcpy(theName, (**theMenuPropToken.theMenuToken.theTokenMenu).menuData);
  2264.                 theErr  = AECreateDesc(typeChar,
  2265.                                                              (Ptr)&theName[1],
  2266.                                                              theName[0],
  2267.                                                              dataDesc);
  2268.             }
  2269.         
  2270.         if (theMenuPropToken.theMenuProp == pMenuID) 
  2271.             {
  2272.                 theErr  = AECreateDesc(typeShortInteger,
  2273.                                                              (Ptr)&theMenuPropToken.theMenuToken.theTokenID,
  2274.                                                              sizeof(theMenuPropToken.theMenuToken.theTokenID),
  2275.                                                              dataDesc);
  2276.             }
  2277.                                 
  2278.         return(theErr);
  2279.     } /* GetMenuProperty */
  2280.     
  2281. /** -----------------------------------------------------------------------
  2282.         Name:             GetMenuItemProperty
  2283.         Purpose:        Fills dataDesc with the requested menu property.
  2284.      -----------------------------------------------------------------------**/
  2285.      
  2286. pascal OSErr GetMenuItemProperty(const AEDesc *theObjToken, AEDesc *dataDesc)
  2287.     {
  2288.       OSErr             theErr;
  2289.         Str255            theName;
  2290.         MenuItemPropToken theMenuItemPropToken;
  2291.         AEDesc            newDesc;
  2292.         Size              tokenSize;
  2293.         
  2294.         theErr = AECoerceDesc(theObjToken, typeMyItemProp, &newDesc);
  2295.         if (theErr==noErr)
  2296.             {
  2297.                 GetRawDataFromDescriptor(&newDesc,
  2298.                                                                  (Ptr)&theMenuItemPropToken,
  2299.                                                                  sizeof(theMenuItemPropToken),
  2300.                                                                  &tokenSize);
  2301.                                                                  
  2302.                 theErr = AEDisposeDesc(&newDesc);
  2303.             }
  2304.         else
  2305.           return(theErr);
  2306.  
  2307.         theErr = kAEGenericErr;
  2308.         
  2309.         if (theMenuItemPropToken.theItemProp == pName) 
  2310.             {
  2311.               GetItem(theMenuItemPropToken.theItemToken.theMenuToken.theTokenMenu,
  2312.                         theMenuItemPropToken.theItemToken.theTokenItem,
  2313.                                 theName);
  2314.                 theErr  = AECreateDesc(typeChar,
  2315.                                                              (Ptr)&theName[1],
  2316.                                                              theName[0],
  2317.                                                              dataDesc);
  2318.             }
  2319.         
  2320.         if (theMenuItemPropToken.theItemProp == pItemNumber) 
  2321.             {
  2322.                 theErr  = AECreateDesc(typeShortInteger,
  2323.                                                              (Ptr)&theMenuItemPropToken.theItemToken.theTokenItem,
  2324.                                                              sizeof(theMenuItemPropToken.theItemToken.theTokenItem),
  2325.                                                              dataDesc);
  2326.             }
  2327.                     
  2328.         return(theErr);
  2329.     } /* GetMenuItemProperty */
  2330.  
  2331. /** -----------------------------------------------------------------------
  2332.         Name:             HandleGetData
  2333.         Purpose:        Coerces theObj into a token which we understand and
  2334.                                 extracts the data requested in the token and puts it
  2335.                                 into dataDesc.
  2336.      -----------------------------------------------------------------------**/
  2337.      
  2338. typedef char chars[32001];
  2339. typedef chars **charsHandle;
  2340.  
  2341. pascal OSErr HandleGetData(AEDesc *theObj, DescType whatType, AEDesc *dataDesc)
  2342.   {
  2343. #pragma unused (whatType)
  2344.  
  2345.       OSErr           myErr;
  2346.         AEDesc          newDesc;
  2347.         TextToken       theTextToken;
  2348.         Size            tokenSize;
  2349.         DPtr            theDoc;
  2350.         AEDesc          objTokenDesc;
  2351.  
  2352.         myErr = errAEWrongDataType;
  2353.         
  2354.         /*
  2355.             Coerce theObj into a token which we can use - 
  2356.                  set the property for that token
  2357.         */
  2358.     
  2359.     
  2360.     myErr = AEResolve(theObj ,kAEIDoMinimum, &objTokenDesc);
  2361.   
  2362.     if (myErr == noErr)    
  2363.     if (objTokenDesc.descriptorType == typeMyApplProp)
  2364.         myErr = GetApplicationProperty(&objTokenDesc, dataDesc);
  2365.     else
  2366.     
  2367.     if (myErr == noErr)    
  2368.     if (objTokenDesc.descriptorType == typeMyMenuProp)
  2369.         myErr = GetMenuProperty(&objTokenDesc, dataDesc);
  2370.     else
  2371.     
  2372.     if (objTokenDesc.descriptorType == typeMyItemProp)
  2373.         myErr = GetMenuItemProperty(&objTokenDesc, dataDesc);
  2374.     else
  2375.     
  2376.     if (objTokenDesc.descriptorType == typeMyTextProp)
  2377.         myErr = GetTextProperty(&objTokenDesc, dataDesc);
  2378.     else
  2379.     
  2380.     if (objTokenDesc.descriptorType == typeMyWindowProp)
  2381.         myErr = GetWindowProperty(&objTokenDesc, dataDesc);
  2382.     else    
  2383.         if (objTokenDesc.descriptorType == typeMyText)
  2384.             if (AECoerceDesc(&objTokenDesc, typeMyText, &newDesc) == noErr) 
  2385.                 {
  2386.                     GetRawDataFromDescriptor(&newDesc,
  2387.                                                                      (Ptr)&theTextToken,
  2388.                                                                      sizeof(theTextToken),
  2389.                                                                      &tokenSize);
  2390.                     
  2391.                     myErr = AEDisposeDesc(&newDesc);
  2392.                                                                      
  2393.                     theDoc                 = DPtrFromWindowPtr(theTextToken.tokenWindow);
  2394.                     
  2395.                     myErr = BuildStyledTextDesc(theDoc->theText,
  2396.                                                                             theTextToken.tokenOffset,
  2397.                                                                             theTextToken.tokenLength,
  2398.                                                                             dataDesc);
  2399.  
  2400.                 }
  2401.             
  2402.         return(myErr);
  2403.     }    /* HandleGetData */
  2404.  
  2405. /** -----------------------------------------------------------------------
  2406.         Name:             DoGetData
  2407.         Purpose:        Handles the GetData AppleEvent.
  2408.      -----------------------------------------------------------------------**/
  2409.  
  2410. pascal OSErr DoGetData(const AppleEvent *theAppleEvent,
  2411.                                          AppleEvent *reply,
  2412.                                          long handlerRefCon)
  2413.     { 
  2414. #pragma unused (handlerRefCon)
  2415.  
  2416.         OSErr    myErr;
  2417.         OSErr    tempErr;
  2418.         AEDesc   myDirObj;
  2419.         AEDesc   myDataDesc;
  2420.         Size     actualSize;
  2421.         DescType returnedType;
  2422.         DescType reqType;
  2423.         
  2424.         myDataDesc.dataHandle = nil;
  2425.         myDirObj.dataHandle   = nil;
  2426.         
  2427.         /*
  2428.             extract the direct object, which is the object whose data is to be returned
  2429.         */
  2430.         
  2431.         myErr  = AEGetParamDesc(theAppleEvent,
  2432.                                                         keyDirectObject,
  2433.                                                         typeWildCard,
  2434.                                                         &myDirObj);
  2435.             
  2436.         /*
  2437.             now the get the type of data wanted - optional
  2438.         */
  2439.         
  2440.         tempErr = AEGetParamPtr(theAppleEvent,
  2441.                                                         keyAERequestedType,
  2442.                                                         typeType,
  2443.                                                         &returnedType,
  2444.                                                         (Ptr)&reqType,
  2445.                                                         sizeof(reqType),
  2446.                                                         &actualSize);
  2447.         
  2448.         if (tempErr!=noErr) 
  2449.             reqType = typeChar;
  2450.             
  2451.         if (myErr == noErr) 
  2452.             myErr = GotRequiredParams(theAppleEvent);
  2453.         
  2454.         /* get the data */
  2455.         if (myErr == noErr) 
  2456.             myErr = HandleGetData(&myDirObj, reqType, &myDataDesc);
  2457.             
  2458.         /* if they wanted a reply, attach it now */
  2459.         if (myErr==noErr) 
  2460.             if (reply->descriptorType != typeNull) 
  2461.                 myErr = AEPutParamDesc(reply, keyDirectObject, &myDataDesc);
  2462.                 
  2463.     if (myDataDesc.dataHandle)
  2464.           tempErr = AEDisposeDesc(&myDataDesc);
  2465.  
  2466.     if (myDirObj.dataHandle)
  2467.           tempErr = AEDisposeDesc(&myDirObj);
  2468.             
  2469.         return(myErr);
  2470.     }    /* DoGetData */
  2471.  
  2472.  
  2473. /** -----------------------------------------------------------------------
  2474.         Name:             DoGetDataSize
  2475.         Purpose:        Handles the GetDataSize AppleEvent.
  2476.      -----------------------------------------------------------------------**/
  2477.  
  2478. pascal OSErr DoGetDataSize(const AppleEvent *theAppleEvent,
  2479.                                                         AppleEvent *reply,
  2480.                                                                  long       handlerRefCon)
  2481.   { 
  2482. #pragma unused (handlerRefCon)
  2483.     
  2484.         OSErr     myErr;
  2485.         OSErr     tempErr;
  2486.         AEDesc    myDirObj;
  2487.         AEDesc    myDataDesc;
  2488.         Size      actualSize;
  2489.         DescType  returnedType;
  2490.         DescType  reqType;
  2491.         long      dataSize;
  2492.         
  2493.         myDataDesc.dataHandle = nil;
  2494.         myDirObj.dataHandle = nil;
  2495.         
  2496.         /* pick up the direct object, which is the object whose data is to be sized */
  2497.         
  2498.         myErr  = AEGetParamDesc(theAppleEvent,
  2499.                                                         keyDirectObject,
  2500.                                                         typeWildCard,
  2501.                                                         &myDirObj);
  2502.             
  2503.         /* now the get the type wanted - optional*/
  2504.         
  2505.         tempErr = AEGetParamPtr(theAppleEvent,
  2506.                                                         keyAERequestedType,
  2507.                                                         typeType,
  2508.                                                         &returnedType,
  2509.                                                         (Ptr)&reqType,
  2510.                                                         sizeof(reqType),
  2511.                                                         &actualSize);
  2512.         
  2513.         if (tempErr!=noErr) 
  2514.             reqType = typeChar;
  2515.             
  2516.         if (myErr == noErr) 
  2517.             myErr = GotRequiredParams(theAppleEvent);
  2518.         
  2519.         /* get the data */
  2520.         if (myErr == noErr) 
  2521.             myErr = HandleGetData(&myDirObj, reqType, &myDataDesc);
  2522.             
  2523.         /* evaluate size of data and discard, create desc for size */
  2524.         if (myErr == noErr) 
  2525.             if (myDataDesc.dataHandle) 
  2526.                 {
  2527.                     dataSize = GetHandleSize((Handle)myDataDesc.dataHandle);
  2528.                     DisposHandle((Handle)myDataDesc.dataHandle);
  2529.                     myErr  = AECreateDesc(typeLongInteger,
  2530.                                                                 (Ptr)&dataSize,
  2531.                                                                 sizeof(dataSize),
  2532.                                                                 &myDataDesc);
  2533.                 }
  2534.             
  2535.             
  2536.         /* if they wanted a reply, attach it now */
  2537.         
  2538.         if (myErr==noErr) 
  2539.             if (reply->descriptorType != typeNull) 
  2540.                 myErr = AEPutParamDesc(reply, keyDirectObject, &myDataDesc);
  2541.                 
  2542.         /* discard our copy */
  2543.         
  2544.         if (myDataDesc.dataHandle) 
  2545.             tempErr = AEDisposeDesc(&myDataDesc);
  2546.                 
  2547.         if (myDirObj.dataHandle) 
  2548.             tempErr = AEDisposeDesc(&myDirObj);
  2549.                 
  2550.         return(myErr);
  2551.     }    /* DoGetDataSize */
  2552.  
  2553. /** -----------------------------------------------------------------------
  2554.         Name:             DoNewElement
  2555.         Purpose:        Handles the NewElement AppleEvent. Only Creates windows for
  2556.                     now.
  2557.      -----------------------------------------------------------------------**/
  2558.  
  2559. pascal OSErr DoNewElement(const AppleEvent *theAppleEvent,
  2560.                                                 AppleEvent *reply, 
  2561.                                                 long       handlerRefCon)
  2562. {
  2563. #pragma unused (handlerRefCon)
  2564.  
  2565.     OSErr       myErr;
  2566.     OSErr       ignoreErr;
  2567.     DescType      returnedType;
  2568.     DescType      newElemClass;
  2569.     Size        actSize;
  2570.     AEDesc        wndwObjSpec;
  2571.     DPtr        theDoc;
  2572.     
  2573.     wndwObjSpec.dataHandle = nil;
  2574.         
  2575.     myErr = AEGetParamPtr(theAppleEvent,
  2576.                                                 keyAEObjectClass,
  2577.                                                 typeType,
  2578.                                                 &returnedType,
  2579.                                                 (Ptr)&newElemClass,
  2580.                                                 sizeof(newElemClass),
  2581.                                                 &actSize);
  2582.             
  2583.   /* check for missing required parameters */
  2584.     
  2585.   if (myErr == noErr) 
  2586.         myErr = GotRequiredParams(theAppleEvent);
  2587.   
  2588.   /* got all required params */
  2589.   
  2590.   /* let's make sure container is the null desc */
  2591.   /* and they want a window */
  2592.     
  2593.   if (newElemClass != cWindow) 
  2594.     myErr = errAEWrongDataType;
  2595.   
  2596.   /* let's create a new window */
  2597.     
  2598.     if (myErr == noErr) 
  2599.         theDoc = NewDocument(false);
  2600.   
  2601.     if (myErr==noErr)
  2602.         if (theDoc == nil) 
  2603.             myErr = -1700;
  2604.         else
  2605.             {
  2606.                 ShowWindow(theDoc->theWindow);
  2607.                 theDoc->dirty = false;
  2608.             
  2609.                 myErr = MakeWindowObj(theDoc->theWindow, &wndwObjSpec);
  2610.             }
  2611.       
  2612.     if (myErr == noErr) 
  2613.         if (reply->descriptorType != typeNull) 
  2614.              myErr = AEPutParamDesc(reply,
  2615.                                                             keyDirectObject,
  2616.                                                             &wndwObjSpec);
  2617.             
  2618.     if (wndwObjSpec.dataHandle) 
  2619.         ignoreErr = AEDisposeDesc(&wndwObjSpec);
  2620.         
  2621.   return(myErr);
  2622. }    /* DoNewElement */
  2623.  
  2624. /** -----------------------------------------------------------------------
  2625.         Name:             DoIsThereA
  2626.         Purpose:        Handles the IsThereA AppleEvent.
  2627.      -----------------------------------------------------------------------**/
  2628.  
  2629. pascal OSErr DoIsThereA(const AppleEvent *theAppleEvent,
  2630.                                             AppleEvent       *reply, 
  2631.                                             long             handlerRefCon)
  2632.                                             
  2633. /*
  2634.     Support check of Windows at first
  2635.     
  2636.     What we do :
  2637.         Get Direct Object
  2638.         Check have all required params
  2639.         Coerce into things we support
  2640.         if we get something back
  2641.             check to see it exists and set reply
  2642.         clean up
  2643.         return
  2644. */
  2645.  
  2646.  {
  2647. #pragma unused (handlerRefCon)
  2648.  
  2649.         OSErr         myErr;
  2650.         OSErr         ignoreErr;
  2651.         AEDesc        myDirObject;
  2652.         AEDesc        windDesc;
  2653.         AEDesc        dataDesc;
  2654.         WindowToken   theWindowToken;
  2655.         Size          tokenSize;
  2656.         Boolean       exists;
  2657.  
  2658.         myDirObject.dataHandle = nil;
  2659.         windDesc.dataHandle    = nil;
  2660.         dataDesc.dataHandle    = nil;
  2661.                 
  2662.         myErr = AEGetParamDesc(theAppleEvent,
  2663.                                                      keyDirectObject,
  2664.                                                      typeWildCard,
  2665.                                                      &myDirObject);
  2666.                         
  2667.         /* check for missing required parameters */
  2668.         
  2669.         if (myErr == noErr) 
  2670.             myErr = GotRequiredParams(theAppleEvent);
  2671.         
  2672.         /* got all required params */
  2673.         
  2674.         /* let's make sure they want to check for a window */
  2675.             
  2676.         exists = false;
  2677.         
  2678.         if (myErr == noErr) 
  2679.             if (AECoerceDesc(&myDirObject, typeMyWndw, &windDesc)==noErr) 
  2680.                 if (windDesc.descriptorType!=typeNull) 
  2681.                     {
  2682.                         GetRawDataFromDescriptor(&windDesc,
  2683.                                                                          (Ptr)&theWindowToken,
  2684.                                                                          sizeof(theWindowToken),
  2685.                                                                          &tokenSize);
  2686.                                                                          
  2687.                         exists = (theWindowToken != nil);    
  2688.                     }
  2689.                     
  2690.         if (myErr == noErr) 
  2691.             myErr = AECreateDesc(typeBoolean,
  2692.                                                      (Ptr)&exists,
  2693.                                                      sizeof(exists),
  2694.                                                      &dataDesc);
  2695.     
  2696.             
  2697.         /* 
  2698.             if they wanted a reply, which they surely must, 
  2699.             attach the result to it…
  2700.         */
  2701.             
  2702.         if (myErr == noErr)
  2703.             if (reply->descriptorType != typeNull) 
  2704.                  myErr = AEPutParamDesc(reply,
  2705.                                                                 keyDirectObject,
  2706.                                                                 &dataDesc);
  2707.                 
  2708.         if (dataDesc.dataHandle) 
  2709.             ignoreErr = AEDisposeDesc(&dataDesc);
  2710.             
  2711.         if (myDirObject.dataHandle) 
  2712.             ignoreErr = AEDisposeDesc(&myDirObject);
  2713.             
  2714.         if (windDesc.dataHandle) 
  2715.             ignoreErr = AEDisposeDesc(&windDesc);
  2716.             
  2717.         return(myErr);
  2718.     }    /* DoIsThereA */
  2719.  
  2720. /** -----------------------------------------------------------------------
  2721.         Name:             DoCloseWindow
  2722.         Purpose:        Handles the Close AppleEvent.
  2723.      -----------------------------------------------------------------------**/
  2724.  
  2725. pascal OSErr DoCloseWindow(const AppleEvent *theAppleEvent,
  2726.                                                     AppleEvent       *reply,
  2727.                                                     long             handlerRefCon)
  2728.     { 
  2729. #pragma unused (reply, handlerRefCon)
  2730.  
  2731.         OSErr         myErr;
  2732.         OSErr         tempErr;
  2733.         AEDesc        myDirObj;
  2734.         AEDesc        newDesc;
  2735.         WindowToken   theWindowToken;
  2736.         Size          tokenSize;
  2737.         DescType      saveOpt;
  2738.         Size          actSize;
  2739.         DescType      returnedType;
  2740.         DPtr          myDPtr;
  2741.  
  2742.         myDirObj.dataHandle = nil;
  2743.         
  2744.         /* pick up the direct object, which is the object (window) to close */
  2745.         
  2746.         myErr = AEGetParamDesc(theAppleEvent,
  2747.                                                      keyDirectObject,
  2748.                                                      typeWildCard,
  2749.                                                      &myDirObj);
  2750.                     
  2751.         /* pick up optional save param, if any */
  2752.         
  2753.         saveOpt = kAEAsk; /* the default */
  2754.         
  2755.         tempErr = AEGetParamPtr(theAppleEvent,
  2756.                                                         keyAESaveOptions,
  2757.                                                         typeEnumerated,
  2758.                                                         &returnedType,
  2759.                                                         (Ptr)&saveOpt,
  2760.                                                         sizeof(saveOpt),
  2761.                                                         &actSize);
  2762.                                                          
  2763.         if (myErr == noErr)
  2764.             myErr = GotRequiredParams(theAppleEvent);
  2765.             
  2766.         /* get the window to close as a window ptr */
  2767.         if (myErr == noErr) 
  2768.             if (AECoerceDesc(&myDirObj, typeMyWndw, &newDesc)==noErr) 
  2769.                 if (newDesc.descriptorType!=typeNull) 
  2770.                     {
  2771.                         GetRawDataFromDescriptor(&newDesc,
  2772.                                                                          (Ptr)&theWindowToken,
  2773.                                                                          sizeof(theWindowToken),
  2774.                                                                          &tokenSize);
  2775.                                                                          
  2776.                         myErr = AEDisposeDesc(&newDesc);
  2777.                         
  2778.                         if (theWindowToken) 
  2779.                             {
  2780.                                 myErr=AESetInteractionAllowed(kAEInteractWithAll); /* Should do this in prefs */
  2781.                                 
  2782.                                 /*
  2783.                                     We do some of the close checks here to avoid
  2784.                                     calling AEInteractWithUser
  2785.                                 */
  2786.                                 myDPtr = DPtrFromWindowPtr(theWindowToken);
  2787.                                 if ((myDPtr->dirty) || (myDPtr->everSaved == false)) 
  2788.                                     if (saveOpt != kAENo) /* Don't flip layers if force no ask */
  2789.                                         myErr = AEInteractWithUser(kAEDefaultTimeout, nil, nil);
  2790.                                     
  2791.                                 if (myErr==noErr) 
  2792.                                     myErr = DoClose(theWindowToken, true, saveOpt);
  2793.                             }
  2794.                         else
  2795.                             myErr =  errAEIllegalIndex;
  2796.                     }
  2797.                         
  2798.         if (myDirObj.dataHandle) 
  2799.             tempErr = AEDisposeDesc(&myDirObj);
  2800.                 
  2801.         return(myErr);
  2802.     }    /* DoCloseWindow */
  2803.  
  2804. /** -----------------------------------------------------------------------
  2805.         Name:             DoSaveWindow
  2806.         Purpose:        Handles the Save AppleEvent.
  2807.      -----------------------------------------------------------------------**/
  2808.  
  2809. pascal OSErr DoSaveWindow(const AppleEvent *theAppleEvent,
  2810.                                                  AppleEvent       *reply,
  2811.                                                  long             handlerRefCon)
  2812.     { 
  2813. #pragma unused (reply, handlerRefCon)
  2814.     
  2815.         OSErr         myErr;
  2816.         OSErr         tempErr;
  2817.         AEDesc        myDirObj;
  2818.         AEDesc        newDesc;
  2819.         WindowToken   theWindowToken;
  2820.         Size          tokenSize;
  2821.         Size          actSize;
  2822.         DescType      returnedType;
  2823.         DPtr          theDoc;
  2824.         FSSpec        destFSSpec;
  2825.         
  2826.         myDirObj.dataHandle = nil;
  2827.         
  2828.         /* pick up the direct object, which is the window to save */
  2829.         
  2830.         myErr = AEGetParamDesc(theAppleEvent,
  2831.                                                      keyDirectObject,
  2832.                                                      typeWildCard,
  2833.                                                      &myDirObj);
  2834.                                                      
  2835.         /* pick up optional destination param, if any */
  2836.     
  2837.         tempErr = AEGetParamPtr(theAppleEvent,
  2838.                                                         keyAEDestination,
  2839.                                                       typeFSS,
  2840.                                                         &returnedType,
  2841.                                                         (Ptr)&destFSSpec,
  2842.                                                         sizeof(destFSSpec),
  2843.                                                         &actSize);
  2844.     
  2845.         if (myErr == noErr) 
  2846.             myErr = GotRequiredParams(theAppleEvent);
  2847.             
  2848.         /* get the data */
  2849.     
  2850.         myErr = AECoerceDesc(&myDirObj, typeMyWndw, &newDesc);
  2851.         
  2852.         if (myErr == noErr)
  2853.             if (newDesc.descriptorType!=typeNull) 
  2854.                 {
  2855.                     GetRawDataFromDescriptor(&newDesc,
  2856.                                                                      (Ptr)&theWindowToken,
  2857.                                                                      sizeof(theWindowToken),
  2858.                                                                      &tokenSize);
  2859.                                                                      
  2860.                     myErr = AEDisposeDesc(&newDesc);
  2861.                                                                      
  2862.                     if (theWindowToken) 
  2863.                         {                            
  2864.                             theDoc = DPtrFromWindowPtr(theWindowToken);
  2865.                             
  2866.                             if (theDoc->everSaved == false) 
  2867.                                 if (tempErr != noErr) 
  2868.                                      /* We had no supplied destination and no default either */
  2869.                                     myErr = kAEGenericErr;
  2870.                             
  2871.                             if (myErr==noErr)
  2872.                                 if (tempErr==noErr)
  2873.                                     { /* we were told where */
  2874.                                         myErr = DoSave(theDoc, destFSSpec); 
  2875.                                         
  2876.                                         if (myErr==noErr)
  2877.                                             AssocAllSections(theDoc);
  2878.                                     }
  2879.                                 else
  2880.                                     myErr = SaveUsingTemp(theDoc);
  2881.                         }
  2882.                     else
  2883.                         myErr =  errAEIllegalIndex;
  2884.                 }
  2885.                 
  2886.         if (myDirObj.dataHandle) 
  2887.             tempErr = AEDisposeDesc(&myDirObj);
  2888.     
  2889.         return(myErr);
  2890.                     
  2891.     }    /* DoSaveWindow */
  2892.  
  2893. /** -----------------------------------------------------------------------
  2894.         Name:             DoRevertWindow
  2895.         Purpose:        Handles the Revert AppleEvent.
  2896.      -----------------------------------------------------------------------**/
  2897.  
  2898. pascal OSErr DoRevertWindow(const AppleEvent *theAppleEvent,
  2899.                                                      AppleEvent       *reply,
  2900.                                                      long             handlerRefCon)
  2901. { 
  2902. #pragma unused (reply, handlerRefCon)
  2903.  
  2904.     OSErr          myErr;
  2905.     OSErr          ignoreErr;
  2906.     AEDesc         myDirObj;
  2907.     AEDesc         newDesc;
  2908.     WindowToken    theWindowToken;
  2909.     Size           tokenSize;
  2910.     DPtr           theDoc;
  2911.     
  2912.     myDirObj.dataHandle = nil;
  2913.     
  2914.   /* pick up the direct object, which is the window to save */
  2915.     
  2916.   myErr = AEGetParamDesc(theAppleEvent,
  2917.                                                  keyDirectObject,
  2918.                                                  typeWildCard,
  2919.                                                  &myDirObj);
  2920.  
  2921.     if (myErr == noErr)
  2922.       myErr = GotRequiredParams(theAppleEvent);
  2923.         
  2924.   /* get the window to revert from the direct object */
  2925.     
  2926.     myErr = AECoerceDesc(&myDirObj, typeMyWndw, &newDesc);
  2927.     
  2928.   if (myErr == noErr) 
  2929.         if (newDesc.descriptorType!=typeNull) 
  2930.             {
  2931.                 GetRawDataFromDescriptor(&newDesc,
  2932.                                                                  (Ptr)&theWindowToken,
  2933.                                                                  sizeof(theWindowToken),
  2934.                                                                  &tokenSize);
  2935.                                                                  
  2936.                 myErr = AEDisposeDesc(&newDesc);
  2937.                                                                  
  2938.                 if (theWindowToken) 
  2939.                     {    
  2940.                         theDoc = DPtrFromWindowPtr(theWindowToken);
  2941.                         
  2942.                         HidePen();
  2943.                         TESetSelect(0, (*(theDoc->theText))->teLength, theDoc->theText);
  2944.                         ShowPen();
  2945.                         TEDelete(theDoc->theText);
  2946.         
  2947.                         if (theDoc->everSaved) 
  2948.                             {
  2949.                                 myErr = GetFileContents(theDoc->theFSSpec, theDoc);
  2950.                                 if (myErr == noErr) 
  2951.                                     {
  2952.                                         ResizeWindow(theDoc);
  2953.                                         theDoc->dirty = false;
  2954.                                     }
  2955.                             }
  2956.         
  2957.                         ShowWindow(theDoc->theWindow); /* <<< Visible already??? */
  2958.                         DoUpdate(theDoc);
  2959.                     }
  2960.                 else
  2961.                     myErr =  errAEIllegalIndex;
  2962.             }
  2963.                 
  2964.     if (myDirObj.dataHandle) 
  2965.         ignoreErr = AEDisposeDesc(&myDirObj);
  2966.         
  2967.   return(myErr);
  2968. }    /* DoRevertWindow */
  2969.  
  2970. /**-----------------------------------------------------------------------
  2971.         Name:             DoPrintDocuments
  2972.         Purpose:        Print a list of documents (or windows).
  2973. -----------------------------------------------------------------------**/
  2974. pascal OSErr DoPrintDocuments(const AppleEvent *message,
  2975.                               AppleEvent       *reply,
  2976.                                                             long refcon)
  2977. {
  2978. #pragma unused (reply, refcon)
  2979.         long          index;
  2980.         long          itemsInList;
  2981.         AEKeyword     keywd;
  2982.         OSErr         err;
  2983.         AEDescList    docList;
  2984.         Size          actSize;
  2985.         DescType      typeCode;
  2986.         FSSpec        theFSSpec;
  2987.         WindowToken   theWindowToken;
  2988.         OSErr         forgetErr;
  2989.         Boolean       talkToUser;
  2990.             
  2991.         err = AEGetParamDesc(message,
  2992.                                                  keyDirectObject,
  2993.                                                  typeAEList,
  2994.                                                  &docList);
  2995.                                                  
  2996.         err = AECountItems(&docList, &itemsInList);
  2997.             
  2998.         for (index = 1; index<=itemsInList; index++)
  2999.             if (err == noErr) 
  3000.                 {
  3001.                     forgetErr = AEGetNthPtr( &docList, index, typeFSS, &keywd,
  3002.                                                                      &typeCode, (Ptr)&theFSSpec, sizeof(theFSSpec), &actSize);
  3003.                                                                         
  3004.                     if (forgetErr == noErr) 
  3005.                         {
  3006.                             if (err == noErr) 
  3007.                                 err = IssueAEOpenDoc(theFSSpec);
  3008.                                 
  3009.                             if (err == noErr) 
  3010.                                 IssuePrintWindow(FrontWindow());
  3011.                                 
  3012.                             if (err == noErr) 
  3013.                                 IssueCloseCommand(FrontWindow());
  3014.                         }
  3015.                     else
  3016.                         { /* wasn't a file - was it a window ? */
  3017.                             err = AEGetNthPtr(&docList,
  3018.                                               index,
  3019.                                               typeMyWndw,
  3020.                                               &keywd,
  3021.                                                                 &typeCode,
  3022.                                                                 (Ptr)&theWindowToken,
  3023.                                                                 sizeof(WindowToken),
  3024.                                                                 &actSize);
  3025.                                                                     
  3026.                             talkToUser = (AEInteractWithUser(kAEDefaultTimeout, nil, nil) == noErr);
  3027.                             
  3028.                             if (err == noErr) 
  3029.                                 PrintWindow(DPtrFromWindowPtr(theWindowToken), talkToUser);
  3030.                         }
  3031.                 }
  3032.         
  3033.         if (docList.dataHandle)
  3034.             forgetErr = AEDisposeDesc(&docList);
  3035.             
  3036.         return(err);
  3037.     } /* DoPrintDocuments */
  3038.  
  3039. /**-----------------------------------------------------------------------
  3040.         Name:             HandleCreatePub
  3041.         Purpose:        Create a publisher.
  3042. -----------------------------------------------------------------------**/
  3043. pascal OSErr HandleCreatePub(const AppleEvent *theAppleEvent,
  3044.                              AppleEvent       *reply,
  3045.                                                          long refcon)
  3046.     {
  3047. #pragma unused (reply, refcon)
  3048.  
  3049.         OSErr       myErr;
  3050.         FSSpec      theFSSpec;
  3051.         OSErr       forgetErr;
  3052.         OSErr       forget2Err;
  3053.         AEDesc      myDirObj;
  3054.         AEDesc      myFileLoc;
  3055.         TextToken   theTextToken;
  3056.         DPtr        theDoc;
  3057.         AEDesc      newDesc;
  3058.         long        tokenSize;
  3059.         Boolean     haveFSSpec;
  3060.         
  3061.         myErr = noErr;
  3062.         
  3063.         forgetErr  = AEGetParamDesc(theAppleEvent,
  3064.                                                                 keyDirectObject,
  3065.                                                                 typeWildCard,
  3066.                                                                 &myDirObj);
  3067.         
  3068.         forget2Err = AEGetParamDesc(theAppleEvent,
  3069.                                                                 keyAEEditionFileLoc,
  3070.                                                                 typeWildCard,
  3071.                                                                 &myFileLoc);
  3072.                                                                  
  3073.         if (myErr==noErr)
  3074.             myErr = GotRequiredParams(theAppleEvent);
  3075.             
  3076.         if (forgetErr==noErr)  /* Set the selection to the supplied object - if any */
  3077.             {
  3078.                 forgetErr = AECoerceDesc(&myDirObj, typeMyText, &newDesc);
  3079.                 if (newDesc.descriptorType!=typeNull) 
  3080.                     {
  3081.                         GetRawDataFromDescriptor(&newDesc,
  3082.                                                                          (Ptr)&theTextToken,
  3083.                                                                          sizeof(theTextToken),
  3084.                                                                          &tokenSize);
  3085.                                                                          
  3086.                         theDoc = DPtrFromWindowPtr(theTextToken.tokenWindow);
  3087.                         
  3088.                         TESetSelect(theTextToken.tokenOffset-1,
  3089.                                                 theTextToken.tokenOffset+
  3090.                                                                     theTextToken.tokenLength-1,
  3091.                                                 theDoc->theText);
  3092.                                                 
  3093.                         forgetErr = AEDisposeDesc(&newDesc);
  3094.                     }
  3095.             }
  3096.         else
  3097.             theDoc = DPtrFromWindowPtr(FrontWindow());
  3098.             
  3099.         if (theDoc==nil) 
  3100.             {
  3101.                 /* Should clean up and exit with error */
  3102.             }
  3103.             
  3104.         haveFSSpec = false;
  3105.         
  3106.         if (forget2Err==noErr)  /* Get the Edition Container File */
  3107.             {
  3108.                 forget2Err = AECoerceDesc(&myDirObj,typeFSS,&newDesc);
  3109.                 if (newDesc.descriptorType!=typeNull) 
  3110.                     {
  3111.                         GetRawDataFromDescriptor(&newDesc,
  3112.                                                                          (Ptr)&theFSSpec,
  3113.                                                                          sizeof(theFSSpec),
  3114.                                                                          &tokenSize);
  3115.                         forget2Err = AEDisposeDesc(&newDesc);
  3116.                         haveFSSpec = true;
  3117.                     }
  3118.             }
  3119.             
  3120.         if (haveFSSpec==false) 
  3121.             myErr = GetEditionContainer(theDoc, &theFSSpec);
  3122.     
  3123.         if (myErr == noErr) 
  3124.             myErr = PublishText(theDoc, &theFSSpec);
  3125.             
  3126.         if (myDirObj.dataHandle)
  3127.             forgetErr = AEDisposeDesc(&myDirObj);
  3128.         
  3129.         if (myFileLoc.dataHandle) 
  3130.             forgetErr = AEDisposeDesc(&myFileLoc);
  3131.         
  3132.         return(myErr);
  3133.         
  3134.     } /* HandleCreatePub */
  3135.  
  3136.  
  3137. pascal OSErr MyCountProc(    DescType desiredType,
  3138.                                                     DescType containerClass,
  3139.                                                     const AEDesc *container,
  3140.                                                     long *result);
  3141.                                             
  3142. /** -----------------------------------------------------------------------
  3143.         Name:       HandleNumberOfElements
  3144.         Purpose:        Handles the Number Of Elements AppleEvent.
  3145.      -----------------------------------------------------------------------**/
  3146.  
  3147. pascal OSErr HandleNumberOfElements(const AppleEvent *theAppleEvent,
  3148.                                                                     AppleEvent *reply,
  3149.                                                                     long       handlerRefCon)
  3150.   {
  3151. #pragma unused (handlerRefCon)
  3152.  
  3153.       OSErr    myErr;
  3154.       OSErr    forgetErr;
  3155.         AEDesc   myDirObj;
  3156.         DescType myClass;
  3157.         long     myCount;
  3158.         DescType returnedType;
  3159.         Size     actSize;
  3160.         
  3161.         myErr                 = errAEEventNotHandled;
  3162.         myDirObj.dataHandle = nil;
  3163.         
  3164.         /* pick up direct object, which is the container in which things are to be counted */
  3165.         
  3166.         myErr = AEGetParamDesc(theAppleEvent,
  3167.                                                      keyDirectObject,
  3168.                                                      typeWildCard,
  3169.                                                      &myDirObj);
  3170.             
  3171.         /* now the class of objects to be counted */
  3172.         
  3173.         myErr = AEGetParamPtr( theAppleEvent,
  3174.                                                      keyAEObjectClass,
  3175.                                                      typeType,
  3176.                                                      &returnedType,
  3177.                                                      (Ptr)&myClass,
  3178.                                                      sizeof(myClass),
  3179.                                                      &actSize);
  3180.             
  3181.         /* missing any parameters? */
  3182.         
  3183.         myErr = GotRequiredParams(theAppleEvent);
  3184.         
  3185.         /* now count */
  3186.     
  3187.         if (myErr == noErr) 
  3188.             myErr = MyCountProc(myClass,myDirObj.descriptorType, &myDirObj,&myCount);
  3189.         
  3190.         /* add result to reply */
  3191.     
  3192.         if (myErr == noErr) 
  3193.             if (reply->descriptorType != typeNull) 
  3194.                  myErr  = AEPutParamPtr(reply,
  3195.                                                                 keyDirectObject,
  3196.                                                                 typeLongInteger,
  3197.                                                                 (Ptr)&myCount,
  3198.                                                                 sizeof(myCount));
  3199.         if (myErr == noErr)       
  3200.             forgetErr  = AEDisposeDesc(&myDirObj);
  3201.         
  3202.         return(myErr);
  3203.         
  3204.     }    /* HandleNumberOfElements */
  3205.  
  3206. /** -----------------------------------------------------------------------
  3207.         Name:             HandleShowSelection
  3208.         Purpose:        Handles the Make Selection Visible AppleEvent.
  3209.      -----------------------------------------------------------------------**/
  3210.  
  3211. pascal OSErr HandleShowSelection(const AppleEvent *theAppleEvent,
  3212.                                                              AppleEvent       *reply,
  3213.                                                              long             handlerRefCon)
  3214.   {
  3215. #pragma unused (reply,handlerRefCon)
  3216.     
  3217.         OSErr       myErr;
  3218.         OSErr       ignoreErr;
  3219.         AEDesc      myDirObj;
  3220.         AEDesc      newDesc;
  3221.         AEDesc      tokenDesc;
  3222.         Size        actSize;
  3223.         WindowToken theWindowToken;
  3224.         DPtr        theDocument;
  3225.         TEHandle    theHTE;
  3226.         
  3227.         myErr      = errAEEventNotHandled;
  3228.         myDirObj.dataHandle  = nil;
  3229.         tokenDesc.dataHandle = nil;
  3230.         
  3231.         /*
  3232.             pick up direct object, i.e. the window in which to show the selection
  3233.         */
  3234.             
  3235.         myErr  = AEGetParamDesc(theAppleEvent,
  3236.                                                         keyDirectObject,
  3237.                                                         typeWildCard,
  3238.                                                         &myDirObj);
  3239.                 
  3240.         /*
  3241.             missing any parameters?
  3242.         */
  3243.         
  3244.         myErr = GotRequiredParams(theAppleEvent);
  3245.         
  3246.         /*
  3247.             convert object to WindowToken which we understand
  3248.         */
  3249.         myErr = AEResolve(&myDirObj, kAEIDoMinimum, &tokenDesc);
  3250.         
  3251.         if (myErr == noErr)
  3252.             if (tokenDesc.descriptorType==typeMyWndw)
  3253.                 {
  3254.                     if (AECoerceDesc(&myDirObj, typeMyWndw, &newDesc) == noErr) 
  3255.                         {
  3256.                             GetRawDataFromDescriptor(&newDesc,
  3257.                                                                              (Ptr)&theWindowToken,
  3258.                                                                              sizeof(theWindowToken),
  3259.                                                                              &actSize);
  3260.         
  3261.                             ignoreErr = AEDisposeDesc(&newDesc);
  3262.                             
  3263.                             if (myErr==noErr) 
  3264.                                 if (theWindowToken)                                                          
  3265.                                     ShowSelect(DPtrFromWindowPtr(theWindowToken));
  3266.                                 else
  3267.                                     myErr = errAEIllegalIndex;
  3268.                         }
  3269.                 }
  3270.             else
  3271.                 if (tokenDesc.descriptorType==typeMyText)
  3272.                     {
  3273.                         myErr = SetSelectionOfAppleEventObject(keyDirectObject,
  3274.                                                                                           theAppleEvent,
  3275.                                                                                            &theDocument,
  3276.                                                                                           &theHTE);
  3277.                         if (theDocument)
  3278.                           ShowSelect(theDocument);
  3279.                         else
  3280.                             myErr = errAEIllegalIndex;
  3281.                     }
  3282.                 else
  3283.                     myErr = errAEEventNotHandled;
  3284.                     
  3285.         if (myDirObj.dataHandle)
  3286.             ignoreErr = AEDisposeDesc(&myDirObj);
  3287.         
  3288.         if (tokenDesc.dataHandle)
  3289.             ignoreErr = AEDisposeDesc(&tokenDesc);
  3290.             
  3291.         return(myErr);
  3292.         
  3293.     }    /* HandleShowSelection */
  3294.  
  3295. pascal OSErr HandleStartRecording(const AppleEvent *theAppleEvent,
  3296.                                                               AppleEvent *reply,
  3297.                                                               long       handlerRefCon)        
  3298.     {
  3299. #pragma unused (reply,handlerRefCon)
  3300.  
  3301.         OSErr myErr;
  3302.  
  3303.       gBigBrother++;
  3304.     
  3305.         myErr = GotRequiredParams(theAppleEvent);
  3306.  
  3307.         return(myErr);
  3308.         
  3309.     }    /* HandleStartRecording */
  3310.  
  3311. pascal OSErr HandleStopRecording(const AppleEvent *theAppleEvent,
  3312.                                                              AppleEvent *reply,
  3313.                                                                  long handlerRefCon)        
  3314.     {
  3315. #pragma unused (theAppleEvent,reply,handlerRefCon)
  3316.     
  3317.         gBigBrother--;
  3318.         return(noErr);
  3319.     }    /* HandleStopRecording */
  3320.  
  3321.  
  3322. #pragma segment AECommandIssuers
  3323.  
  3324. /*******************************************************************************/
  3325. /* 
  3326.         Start of section involved in building and sending AppleEvent Objects as/with
  3327.         commands
  3328.  */
  3329.  
  3330. /*
  3331.     Make an AEDesc that describes the selection in the window and text edit
  3332.     record supplied
  3333. */
  3334.  
  3335. pascal OSErr MakeWindowObj(WindowPtr theWindow,
  3336.                                                    AEDesc    *dMyDoc)
  3337.     {
  3338.             AEDesc   dNull;
  3339.             AEDesc   dDocName;
  3340.             Str255   windowName;
  3341.             OSErr    myErr;
  3342.             
  3343.             GetWTitle(theWindow, windowName);
  3344.             myErr = AECreateDesc(typeChar,(Ptr)&windowName[1], windowName[0], &dDocName);
  3345.             
  3346.             if (myErr==noErr) 
  3347.                 myErr = AECreateDesc(typeNull, nil , 0, &dNull);
  3348.             
  3349.             if (myErr==noErr) 
  3350.                 myErr = CreateObjSpecifier(cWindow, &dNull, formName, &dDocName, true, dMyDoc);
  3351.             
  3352.             return(myErr);
  3353.             
  3354.     } /*MakeWindowObj*/
  3355.     
  3356. pascal OSErr MakeTextObj(WindowPtr theWindow,
  3357.                                                  short     selStart,
  3358.                                                  short     selEnd,
  3359.                                                AEDesc    *selTextObj)
  3360.     {
  3361.         OSErr    myErr;
  3362.         OSErr    ignoreErr;
  3363.         AEDesc   dMyDoc;
  3364.         AEDesc   startOfs;
  3365.         AEDesc   endOfs;
  3366.         AEDesc   startObj;
  3367.         AEDesc   endObj;
  3368.         AEDesc   rangeDesc;
  3369.         long     startChar;
  3370.         long     endChar;
  3371.         Boolean  spotFlag;
  3372.             
  3373.         myErr = noErr;
  3374.         
  3375.         if (theWindow==nil) 
  3376.             return(noErr);
  3377.             
  3378.         selTextObj->dataHandle = nil;
  3379.         dMyDoc.dataHandle      = nil;
  3380.         startObj.dataHandle    = nil;
  3381.         endObj.dataHandle      = nil;
  3382.         
  3383.         /* 
  3384.             make the window object 
  3385.         */
  3386.         
  3387.         myErr = MakeWindowObj(theWindow, &dMyDoc);
  3388.             
  3389.         if (myErr==noErr)
  3390.             {
  3391.                 /* get the start and end of selection */
  3392.                 
  3393.                 startChar = selStart+1;    /* start counting obj's from 1, not 0 */
  3394.                 endChar   = selEnd;
  3395.                 spotFlag  = (selStart == selEnd);
  3396.                     
  3397.                 myErr = CreateOffsetDescriptor(startChar, &startOfs);
  3398.                             
  3399.                 if (myErr==noErr)
  3400.                     if (spotFlag)
  3401.                         myErr = CreateObjSpecifier(cSpot,
  3402.                                                                              &dMyDoc,
  3403.                                                                              formAbsolutePosition, 
  3404.                                                                              &startOfs, 
  3405.                                                                              true, 
  3406.                                                                              selTextObj);
  3407.                     else
  3408.                         {
  3409.                             /* not a spot - must represent as range */
  3410.                             /* make obj for start char */
  3411.                             
  3412.                             myErr = CreateObjSpecifier(cChar,
  3413.                                                        &dMyDoc,
  3414.                                                                                  formAbsolutePosition,
  3415.                                                                                  &startOfs,
  3416.                                                                                  false,
  3417.                                                                                  &startObj);
  3418.                             
  3419.                             if (myErr==noErr) 
  3420.                                 myErr = CreateOffsetDescriptor(endChar, &endOfs);
  3421.                             
  3422.                             if (myErr==noErr) 
  3423.                                 myErr = CreateObjSpecifier(cChar,
  3424.                                                                                      &dMyDoc,
  3425.                                                                                      formAbsolutePosition,
  3426.                                                                                      &endOfs,
  3427.                                                                                      false,
  3428.                                                                                      &endObj);
  3429.                             
  3430.                             if (myErr==noErr) 
  3431.                                 myErr = CreateRangeDescriptor(&startObj,
  3432.                                                                                             &endObj,
  3433.                                                                                             false,
  3434.                                                                                             &rangeDesc);
  3435.                             
  3436.                             if (myErr==noErr) 
  3437.                                 myErr = CreateObjSpecifier(cChar,
  3438.                                                                                      &dMyDoc,
  3439.                                                                                      formRange,
  3440.                                                                                      &rangeDesc,
  3441.                                                                                      true,
  3442.                                                                                      selTextObj);
  3443.                                                                                      
  3444.                             if (startObj.dataHandle)
  3445.                               ignoreErr = AEDisposeDesc(&startObj);
  3446.                                 
  3447.                             if (startOfs.dataHandle)
  3448.                               ignoreErr = AEDisposeDesc(&startOfs);
  3449.                                 
  3450.                             if (endObj.dataHandle)
  3451.                               ignoreErr = AEDisposeDesc(&endObj);
  3452.                                 
  3453.                             if (endOfs.dataHandle)
  3454.                               ignoreErr = AEDisposeDesc(&endOfs);
  3455.                         }
  3456.             }
  3457.             
  3458.         return(myErr);
  3459.     }
  3460.     
  3461. pascal OSErr MakeSelectedTextObj(WindowPtr theWindow,
  3462.                                                                  TEHandle  theTextEditHandle,
  3463.                                                                  AEDesc    *selTextObj)
  3464.     {
  3465.         return( MakeTextObj(theWindow,
  3466.                                                 (**theTextEditHandle).selStart,
  3467.                                                 (**theTextEditHandle).selEnd,
  3468.                                               selTextObj));
  3469.                                                 
  3470.     }    /* MakeSelectedTextObj */
  3471.  
  3472. enum editCommandType {
  3473. editCutCommand   = 1,
  3474. editCopyCommand  = 2,
  3475. editPasteCommand = 3,
  3476. editClearCommand = 4
  3477. };
  3478.  
  3479. typedef enum editCommandType editCommandType;
  3480.  
  3481. pascal void DoEditCommand(DPtr theDocument,editCommandType whatCommand)
  3482.     {
  3483.       OSErr         err;
  3484.       OSErr         forgetErr;
  3485.         AEAddressDesc ourAddress;
  3486.         AppleEvent    editCommandEvent;
  3487.         AppleEvent    ignoreReply;
  3488.         AEDesc        ourTextSelObj;
  3489.         AEEventID     theEventID;
  3490.         AEEventClass  theEventClass;
  3491.  
  3492.         /*
  3493.                 Initialise
  3494.         */
  3495.  
  3496.         ourAddress.dataHandle             = nil;
  3497.         ourTextSelObj.dataHandle         = nil;
  3498.         editCommandEvent.dataHandle = nil;
  3499.         ignoreReply.dataHandle             = nil;
  3500.         
  3501.         err = MakeSelfAddress(&ourAddress);
  3502.         
  3503.         /*
  3504.             Build an object to represent the current document's selection
  3505.         */
  3506.         err = MakeSelectedTextObj(theDocument->theWindow, theDocument->theText, &ourTextSelObj);
  3507.         
  3508.         if (err==noErr)
  3509.           {
  3510.                 switch (whatCommand) {
  3511.                     case  editCutCommand         : theEventID    = kAECut;
  3512.                                                                         theEventClass = kAEMiscStandards;
  3513.                                                                         break;
  3514.                     case  editCopyCommand     : theEventID    = kAECopy;
  3515.                                                                         theEventClass = kAEMiscStandards;
  3516.                                                                         break;
  3517.                     case  editPasteCommand     : theEventID    = kAEPaste;
  3518.                                                                         theEventClass = kAEMiscStandards;
  3519.                                                                         break;
  3520.                     case  editClearCommand     : theEventID    = kAEDelete;
  3521.                                                                         theEventClass = kAECoreSuite;
  3522.                                                                         break;
  3523.                 }
  3524.                     
  3525.                 err = AECreateAppleEvent( theEventClass, theEventID, &ourAddress, 0, 0, &editCommandEvent);    
  3526.  
  3527.                 /* add parameter */    
  3528.                 if (err==noErr) 
  3529.                     err = AEPutParamDesc(&editCommandEvent, keyDirectObject, &ourTextSelObj);
  3530.                     
  3531.                 /*and now Send the message*/
  3532.                 if (err==noErr)
  3533.                     err = AESend(&editCommandEvent,&ignoreReply,kAENoReply,kAEHighPriority,10000,nil, nil);
  3534.             }              
  3535.             
  3536.         /*
  3537.             Clean up
  3538.         */
  3539.         if (ourAddress.dataHandle) 
  3540.             forgetErr = AEDisposeDesc(&ourAddress);
  3541.         
  3542.         if (editCommandEvent.dataHandle) 
  3543.             forgetErr = AEDisposeDesc(&editCommandEvent);
  3544.         
  3545.         if (ignoreReply.dataHandle) 
  3546.             forgetErr = AEDisposeDesc(&ignoreReply);
  3547.             
  3548.         if (ourTextSelObj.dataHandle) 
  3549.             forgetErr = AEDisposeDesc(&ourTextSelObj);
  3550.             
  3551.     } /*DoEditCommand*/
  3552.     
  3553. pascal void IssueCutCommand(DPtr theDocument)
  3554.     {            
  3555.         DoEditCommand(theDocument, editCutCommand);
  3556.     } 
  3557.     
  3558. pascal void IssueCopyCommand(DPtr theDocument)
  3559.     {
  3560.         DoEditCommand(theDocument, editCopyCommand);
  3561.     }
  3562.     
  3563. pascal void IssuePasteCommand(DPtr theDocument)
  3564.     {
  3565.         DoEditCommand(theDocument, editPasteCommand);    
  3566.     }
  3567.     
  3568. pascal void IssueClearCommand(DPtr theDocument)
  3569.     {
  3570.         DoEditCommand(theDocument, editClearCommand);    
  3571.     }
  3572.     
  3573. pascal void IssueFontCommand(DPtr theDocument, short theItem)
  3574.     {
  3575.        Str255         name;
  3576.          AEDesc           strDesc;
  3577.          AEAddressDesc  theAddress;
  3578.          OSErr            err;
  3579.          AEDesc         selTextObj;
  3580.             
  3581.         err = MakeSelfAddress(&theAddress);
  3582.         
  3583.         err = MakeSelectedTextObj(theDocument->theWindow,
  3584.                                                             theDocument->theText,
  3585.                                                             &selTextObj);
  3586.         
  3587.         GetItem(myMenus[fontM], theItem, name);
  3588.         
  3589.         if (err==noErr)
  3590.             err  = AECreateDesc(typeChar,
  3591.                                                     (Ptr)&name[1],
  3592.                                                     name[0],
  3593.                                                     &strDesc);
  3594.         
  3595.         if (err==noErr)
  3596.             err  = SendAESetObjProp(&selTextObj, 
  3597.                                                             pFont,
  3598.                                                             &strDesc,
  3599.                                                             &theAddress);                                                            
  3600.     }
  3601.     
  3602. /*
  3603.     Window property routines
  3604. */
  3605.  
  3606. pascal void IssueZoomCommand(WindowPtr whichWindow, short whichPart)
  3607.     {
  3608.       Boolean       zoomBool;
  3609.         AEDesc        zoomDesc;
  3610.         AEAddressDesc selfAddr;
  3611.         AEDesc        frontWinObj;
  3612.         OSErr         err;
  3613.     
  3614.         err = MakeSelfAddress(&selfAddr);
  3615.         
  3616.         err = MakeWindowObj(whichWindow, &frontWinObj);
  3617.         
  3618.         zoomBool = (whichPart==inZoomOut);
  3619.     
  3620.         err = AECreateDesc(typeBoolean,
  3621.                                              (Ptr)&zoomBool,
  3622.                                              sizeof(zoomBool),
  3623.                                              &zoomDesc);
  3624.                                                 
  3625.         err = SendAESetObjProp(&frontWinObj, 
  3626.                                                      pIsZoomed,
  3627.                                                      &zoomDesc,
  3628.                                                      &selfAddr);                                                            
  3629.     } /* IssueZoomCommand */
  3630.     
  3631. pascal void IssueCloseCommand(WindowPtr whichWindow)
  3632.     {
  3633.         AEAddressDesc  selfAddr;
  3634.         AEDesc         frontWinObj;
  3635.         OSErr          err;
  3636.         OSErr          ignoreErr;
  3637.         AppleEvent     closeCommandEvent;
  3638.         AppleEvent     ignoreReply;
  3639.     
  3640.         frontWinObj.dataHandle = nil;
  3641.         
  3642.         err = MakeSelfAddress(&selfAddr);
  3643.         
  3644.         err = MakeWindowObj(whichWindow, &frontWinObj);
  3645.                                                             
  3646.         err = AECreateAppleEvent( kAECoreSuite, kAEClose, &selfAddr, 0, 0, &closeCommandEvent) ;                
  3647.         
  3648.         /* add parameter - the window to close */    
  3649.         if (err==noErr) 
  3650.             err = AEPutParamDesc(&closeCommandEvent, keyDirectObject, &frontWinObj);
  3651.             
  3652.         if (err==noErr) 
  3653.             err = AESend(&closeCommandEvent,&ignoreReply,kAENoReply+kAEAlwaysInteract,kAEHighPriority,10000,nil, nil);
  3654.         
  3655.         if (closeCommandEvent.dataHandle) 
  3656.             ignoreErr = AEDisposeDesc(&closeCommandEvent);
  3657.         
  3658.         if (selfAddr.dataHandle) 
  3659.             ignoreErr = AEDisposeDesc(&selfAddr);
  3660.             
  3661.         if (frontWinObj.dataHandle) 
  3662.             ignoreErr = AEDisposeDesc(&frontWinObj);
  3663.             
  3664.     } /* IssueCloseCommand */
  3665.     
  3666. pascal void IssueSizeWindow(WindowPtr whichWindow, short newHSize, short newVSize)
  3667.     {
  3668.       Rect          sizeRect;
  3669.         Rect          contentRect;
  3670.         short         edgeSize;
  3671.         AEDesc        sizeDesc;
  3672.         AEAddressDesc selfAddr;
  3673.         AEDesc        frontWinObj;
  3674.         OSErr         err;
  3675.     
  3676.         sizeRect    = (**(((WindowPeek)whichWindow)->strucRgn)).rgnBBox;
  3677.         contentRect = (**(((WindowPeek)whichWindow)->contRgn)).rgnBBox;
  3678.         
  3679.         edgeSize = sizeRect.right-sizeRect.left-(contentRect.right-contentRect.left);
  3680.         sizeRect.right = sizeRect.left+newHSize+edgeSize;
  3681.         
  3682.         edgeSize = sizeRect.bottom-sizeRect.top-(contentRect.bottom-contentRect.top);
  3683.         sizeRect.bottom = sizeRect.top+newVSize+edgeSize;
  3684.         
  3685.         err = MakeSelfAddress(&selfAddr);
  3686.         
  3687.         err = MakeWindowObj(whichWindow, &frontWinObj);
  3688.         
  3689.         if (err==noErr)
  3690.             err = AECreateDesc(typeQDRectangle,
  3691.                                                  (Ptr)&sizeRect,
  3692.                                                  sizeof(sizeRect),
  3693.                                                  &sizeDesc);
  3694.         
  3695.         if (err==noErr)
  3696.             err  = SendAESetObjProp(&frontWinObj, 
  3697.                                                             pBounds,
  3698.                                                             &sizeDesc,
  3699.                                                             &selfAddr);                                                            
  3700.     } /*IssueSizeWindow*/
  3701.     
  3702. pascal void IssueMoveWindow(WindowPtr whichWindow, Rect sizeRect)
  3703.     {
  3704.         AEDesc        sizeDesc;
  3705.         AEAddressDesc selfAddr;
  3706.         AEDesc        frontWinObj;
  3707.         OSErr         err;
  3708.     
  3709.         err = MakeSelfAddress(&selfAddr);
  3710.         
  3711.         err = MakeWindowObj(whichWindow, &frontWinObj);
  3712.             
  3713.         if (err==noErr)
  3714.             err = AECreateDesc(typeQDRectangle,
  3715.                                                  (Ptr)&sizeRect,
  3716.                                                  sizeof(sizeRect),
  3717.                                                  &sizeDesc);
  3718.         
  3719.         if (err==noErr)        
  3720.             err = SendAESetObjProp(&frontWinObj, 
  3721.                                                          pBounds,
  3722.                                                          &sizeDesc,
  3723.                                                          &selfAddr);                                                            
  3724.     } /*IssueMoveWindow*/
  3725.  
  3726. pascal void IssuePageSetupWindow(WindowPtr whichWindow, TPrint thePageSetup)
  3727.     {
  3728.         AEDesc        sizeDesc;
  3729.         AEAddressDesc selfAddr;
  3730.         AEDesc        frontWinObj;
  3731.         OSErr         err;
  3732.     
  3733.         err = MakeSelfAddress(&selfAddr);
  3734.         
  3735.         err = MakeWindowObj(whichWindow, &frontWinObj);
  3736.         
  3737.         if (err==noErr)
  3738.             err = AECreateDesc(typeTPrint,
  3739.                                                  (Ptr)&thePageSetup,
  3740.                                                  sizeof(thePageSetup),
  3741.                                                  &sizeDesc);
  3742.                                                  
  3743.         if (err==noErr)
  3744.             err = SendAESetObjProp(&frontWinObj, 
  3745.                                                          pPageSetup,
  3746.                                                          &sizeDesc,
  3747.                                                          &selfAddr);                                                            
  3748.                                                      
  3749.     } /*IssuePageSetupWindow*/
  3750.     
  3751. pascal void IssueShowBorders(WindowPtr whichWindow, Boolean showBorders)
  3752.     {
  3753.         AEDesc        sizeDesc;
  3754.         AEAddressDesc selfAddr;
  3755.         AEDesc        frontWinObj;
  3756.         OSErr         err;
  3757.     
  3758.         err = MakeSelfAddress(&selfAddr);
  3759.         
  3760.         err = MakeWindowObj(whichWindow, &frontWinObj);
  3761.         
  3762.         if (err==noErr)
  3763.             err = AECreateDesc(typeBoolean,
  3764.                                                  (Ptr)&showBorders,
  3765.                                                  sizeof(showBorders),
  3766.                                                  &sizeDesc);
  3767.         
  3768.         if (err==noErr)
  3769.             err = SendAESetObjProp(&frontWinObj, 
  3770.                                                          pShowBorders,
  3771.                                                          &sizeDesc,
  3772.                                                          &selfAddr);                                                            
  3773.     } /*IssueShowBorders*/
  3774.     
  3775. pascal void IssuePrintWindow(WindowPtr whichWindow)
  3776.     {
  3777.         AEAddressDesc selfAddr;
  3778.         AEDesc        frontWinObj;
  3779.         OSErr         err;
  3780.         OSErr         ignoreErr;
  3781.         AppleEvent    printCommandEvent;
  3782.         AppleEvent    ignoreReply;
  3783.     
  3784.         err = MakeSelfAddress(&selfAddr);
  3785.         
  3786.         err = MakeWindowObj(whichWindow, &frontWinObj);
  3787.                                                             
  3788.         err = AECreateAppleEvent(kCoreEventClass, kAEPrintDocuments, &selfAddr, 0, 0, &printCommandEvent) ;                
  3789.  
  3790.         /* 
  3791.             add parameter - the window to print
  3792.         */    
  3793.  
  3794.         if (err==noErr) 
  3795.             err = AEPutParamDesc(&printCommandEvent, keyDirectObject, &frontWinObj);
  3796.             
  3797.         if (err==noErr) 
  3798.             err = AESend(&printCommandEvent,&ignoreReply,kAENoReply+kAEAlwaysInteract,kAEHighPriority,10000,nil, nil);
  3799.     
  3800.       if (printCommandEvent.dataHandle)
  3801.             ignoreErr = AEDisposeDesc(&printCommandEvent);
  3802.         
  3803.         if (frontWinObj.dataHandle) 
  3804.             err = AEDisposeDesc(&frontWinObj);
  3805.             
  3806.         if (selfAddr.dataHandle) 
  3807.             err = AEDisposeDesc(&selfAddr);
  3808.             
  3809.     } /*IssuePrintWindow*/
  3810.     
  3811. pascal OSErr IssueAEOpenDoc(FSSpec myFSSpec)
  3812. /* send OpenDocs AppleEvent to myself, with a one-element list
  3813.   containing the given file spec
  3814.  
  3815.   NOTES : the core AEOpenDocs event is defined as taking a list of
  3816.           aliases (not file specs) as its direct parameter.  However,
  3817.             we can send the file spec instead and depend on AppleEvents'
  3818.             automatic coercion.  In fact, we don't really even have to put 
  3819.             in a list; AppleEvents will coerce a descriptor into a 1-element
  3820.             list if called for.  In this routine, though, we'll make the
  3821.             list for demonstration purposes.
  3822. */
  3823.  
  3824.  {
  3825.          AppleEvent    myAppleEvent;
  3826.         AppleEvent    defReply;
  3827.         AEDescList    docList;
  3828.         AEAddressDesc selfAddr;
  3829.         OSErr         myErr;
  3830.         OSErr         ignoreErr;
  3831.         
  3832.         myAppleEvent.dataHandle = nil;
  3833.         docList.dataHandle  = nil;
  3834.         selfAddr.dataHandle = nil;
  3835.         defReply.dataHandle = nil;
  3836.             
  3837.         /*
  3838.             Create empty list and add one file spec
  3839.         */
  3840.         myErr = AECreateList(nil,0,false, &docList);
  3841.         
  3842.         if (myErr==noErr) 
  3843.             myErr = AEPutPtr(&docList,1,typeFSS,(Ptr)&myFSSpec,sizeof(myFSSpec));
  3844.             
  3845.         /*
  3846.             Create a self address to send it to
  3847.         */
  3848.         if (myErr==noErr) 
  3849.             myErr = MakeSelfAddress(&selfAddr);
  3850.             
  3851.         if (myErr==noErr) 
  3852.             myErr = AECreateAppleEvent(kCoreEventClass,
  3853.                                                                  kAEOpenDocuments,
  3854.                                                                  &selfAddr,
  3855.                                                                  kAutoGenerateReturnID,
  3856.                                                                  kAnyTransactionID,
  3857.                                                                  &myAppleEvent);
  3858.     
  3859.         /* 
  3860.             Put Params into our event and send it
  3861.         */
  3862.         if (myErr == noErr) 
  3863.             myErr = AEPutParamDesc(&myAppleEvent,
  3864.                                                          keyDirectObject,
  3865.                                                          &docList);
  3866.     
  3867.         myErr = AESend(&myAppleEvent,
  3868.                                      &defReply,
  3869.                                      kAENoReply+kAEAlwaysInteract,
  3870.                                      kAENormalPriority,
  3871.                                      kAEDefaultTimeout,
  3872.                                      nil,
  3873.                                      nil);
  3874.             
  3875.         if (selfAddr.dataHandle) 
  3876.             ignoreErr = AEDisposeDesc(&selfAddr);
  3877.             
  3878.         if (myAppleEvent.dataHandle) 
  3879.             ignoreErr = AEDisposeDesc(&myAppleEvent);
  3880.             
  3881.         if (docList.dataHandle) 
  3882.             ignoreErr = AEDisposeDesc(&docList);
  3883.             
  3884.         return(myErr);
  3885.         
  3886.     }    /* IssueAEOpenDoc */
  3887.  
  3888. pascal void IssueAENewWindow(void)
  3889. /* 
  3890.     send the New Element event to myself with a null container
  3891. */
  3892.     {
  3893.       AppleEvent    myAppleEvent;
  3894.         AppleEvent    defReply;
  3895.         AEAddressDesc selfAddr;
  3896.         OSErr         myErr;
  3897.         OSErr         ignoreErr;
  3898.         DescType      elemClass;
  3899.         
  3900.         myAppleEvent.dataHandle = nil;
  3901.         
  3902.         /*
  3903.             Create the address of us
  3904.         */
  3905.         
  3906.         myErr = MakeSelfAddress(&selfAddr);
  3907.         
  3908.         /*
  3909.             create event 
  3910.         */
  3911.         
  3912.         myErr = AECreateAppleEvent(kAECoreSuite,
  3913.                                                              kAECreateElement,
  3914.                                                              &selfAddr,
  3915.                                                              kAutoGenerateReturnID,
  3916.                                                              kAnyTransactionID,
  3917.                                                              &myAppleEvent);
  3918.         
  3919.         /*
  3920.             attach desired class of new element
  3921.         */
  3922.         
  3923.         elemClass = cWindow;
  3924.         
  3925.         if (myErr == noErr) 
  3926.             myErr = AEPutParamPtr(&myAppleEvent,
  3927.                                                       keyAEObjectClass,
  3928.                                                         typeType,
  3929.                                                         (Ptr)&elemClass,
  3930.                                                         sizeof(elemClass));
  3931.             
  3932.         /*
  3933.             send the event 
  3934.         */
  3935.         
  3936.         if (myErr == noErr) 
  3937.             myErr = AESend(&myAppleEvent,
  3938.                                          &defReply,
  3939.                                          kAENoReply+kAENeverInteract,
  3940.                                          kAENormalPriority,
  3941.                                          kAEDefaultTimeout,
  3942.                                          nil,
  3943.                                          nil);
  3944.         /*
  3945.             Clean up - reply never created so don't throw away
  3946.         */
  3947.         if (selfAddr.dataHandle) 
  3948.             ignoreErr = AEDisposeDesc(&selfAddr);
  3949.             
  3950.         if (myAppleEvent.dataHandle) 
  3951.             ignoreErr = AEDisposeDesc(&myAppleEvent);
  3952.                     
  3953.     }    /* IssueAENewWindow */
  3954.  
  3955. pascal OSErr IssueSaveCommand(WindowPtr theWindow,
  3956.                               FSSpecPtr where)
  3957. /*
  3958.     send an AppleEvent Save Event to myself
  3959. */
  3960.  
  3961. {
  3962.     AEDesc        windowObj;
  3963.     AppleEvent    myAppleEvent;
  3964.     AppleEvent    defReply;
  3965.     OSErr         myErr;
  3966.     OSErr         ignoreErr;
  3967.     AEAddressDesc selfAddr;
  3968.         
  3969.     windowObj.dataHandle = nil;
  3970.     myAppleEvent.dataHandle = nil;
  3971.     
  3972.     myErr = MakeWindowObj(theWindow, &windowObj);
  3973.             
  3974.     if (myErr==noErr) 
  3975.         myErr = MakeSelfAddress(&selfAddr);
  3976.         
  3977.   /*
  3978.         Build event
  3979.     */
  3980.     
  3981.   if (myErr == noErr) 
  3982.         myErr = AECreateAppleEvent(kAECoreSuite,
  3983.                                                              kAESave,
  3984.                                                              &selfAddr,
  3985.                                                              kAutoGenerateReturnID,
  3986.                                                              kAnyTransactionID,
  3987.                                                              &myAppleEvent);
  3988.       
  3989.   /*
  3990.         say which window
  3991.     */
  3992.     
  3993.   if (myErr==noErr) 
  3994.         myErr = AEPutParamDesc(&myAppleEvent,
  3995.                                                      keyDirectObject,
  3996.                                                      &windowObj);
  3997.   
  3998.   /*
  3999.         add optional file param if we need to
  4000.     */
  4001.     
  4002.   if (where) 
  4003.         if (myErr==noErr) 
  4004.             myErr = AEPutParamPtr(&myAppleEvent,
  4005.                                                         keyAEDestination,
  4006.                                                         typeFSS,
  4007.                                                         (Ptr)where,
  4008.                                                         sizeof(FSSpec));
  4009.         
  4010.   /*
  4011.         send the event
  4012.     */
  4013.   if (myErr==noErr) 
  4014.         myErr  = AESend(&myAppleEvent,
  4015.                                         &defReply,
  4016.                                         kAENoReply+kAENeverInteract,
  4017.                                         kAENormalPriority,
  4018.                                         kAEDefaultTimeout,
  4019.                                         nil,
  4020.                                         nil);
  4021.       
  4022.     if (selfAddr.dataHandle) 
  4023.         ignoreErr = AEDisposeDesc(&selfAddr);
  4024.       
  4025.     if (windowObj.dataHandle) 
  4026.         ignoreErr = AEDisposeDesc(&windowObj);
  4027.         
  4028.     if (myAppleEvent.dataHandle) 
  4029.         myErr = AEDisposeDesc(&myAppleEvent);
  4030.         
  4031.     return(myErr);
  4032. }    /* IssueSaveCommand */
  4033.  
  4034. pascal OSErr IssueRevertCommand(WindowPtr theWindow)
  4035. /*
  4036.     send an AppleEvent Revert Event to myself
  4037. */
  4038.  
  4039.     {
  4040.         AEDesc        windowObj;
  4041.         AppleEvent    myAppleEvent;
  4042.         AppleEvent    defReply;
  4043.         OSErr         myErr;
  4044.         OSErr         ignoreErr;
  4045.         AEAddressDesc selfAddr;
  4046.         
  4047.         windowObj.dataHandle = nil;
  4048.         myAppleEvent.dataHandle = nil;
  4049.         
  4050.         myErr = MakeWindowObj(theWindow, &windowObj);
  4051.                     
  4052.         if (myErr==noErr) 
  4053.             myErr = MakeSelfAddress(&selfAddr);
  4054.             
  4055.         /*
  4056.             Build event
  4057.         */
  4058.         
  4059.         if (myErr == noErr) 
  4060.             myErr  = AECreateAppleEvent(kAEMiscStandards,
  4061.                                                                     kAERevert,
  4062.                                                                     &selfAddr,
  4063.                                                                     kAutoGenerateReturnID,
  4064.                                                                     kAnyTransactionID,
  4065.                                                                     &myAppleEvent);
  4066.         /*
  4067.             say which window
  4068.         */
  4069.         
  4070.         if (myErr == noErr) 
  4071.             myErr = AEPutParamDesc(&myAppleEvent,
  4072.                                                          keyDirectObject,
  4073.                                                          &windowObj);
  4074.         /*
  4075.             send the event
  4076.         */
  4077.         if (myErr==noErr) 
  4078.             myErr  = AESend(&myAppleEvent,
  4079.                                             &defReply,
  4080.                                             kAENoReply+kAENeverInteract,
  4081.                                             kAENormalPriority,
  4082.                                             kAEDefaultTimeout,
  4083.                                             nil,
  4084.                                             nil);
  4085.             
  4086.         if (windowObj.dataHandle) 
  4087.             ignoreErr = AEDisposeDesc(&windowObj);
  4088.             
  4089.         if (myAppleEvent.dataHandle) 
  4090.             ignoreErr = AEDisposeDesc(&myAppleEvent);
  4091.             
  4092.         if (selfAddr.dataHandle) 
  4093.             ignoreErr = AEDisposeDesc(&selfAddr);
  4094.             
  4095.         return(myErr);
  4096.     }    /* IssueRevertCommand */
  4097.  
  4098. /*
  4099.     Name : IssueQuitCommand
  4100.     Purpose : Sends self a Quit AppleEvent
  4101. */
  4102. pascal OSErr IssueQuitCommand(void)
  4103.     {
  4104.         AppleEvent    myAppleEvent;
  4105.         AppleEvent    defReply;
  4106.         OSErr         myErr;
  4107.         OSErr         ignoreErr;
  4108.         AEAddressDesc selfAddr;
  4109.         DescType      mySaveOpt;
  4110.         
  4111.         myAppleEvent.dataHandle = nil;
  4112.         selfAddr.dataHandle     = nil;
  4113.                             
  4114.         myErr = MakeSelfAddress(&selfAddr);
  4115.             
  4116.         /*
  4117.             Build event
  4118.         */
  4119.         
  4120.         if (myErr == noErr) 
  4121.             myErr  = AECreateAppleEvent(kCoreEventClass,
  4122.                                                                     kAEQuitApplication,
  4123.                                                                     &selfAddr,
  4124.                                                                     kAutoGenerateReturnID,
  4125.                                                                     kAnyTransactionID,
  4126.                                                                     &myAppleEvent);
  4127.         /*
  4128.             say which save option
  4129.         */
  4130.         
  4131.         mySaveOpt = kAEAsk;
  4132.         
  4133.         if (myErr == noErr) 
  4134.             myErr = AEPutParamPtr(&myAppleEvent,
  4135.                                                         keyAESaveOptions,
  4136.                                                         typeEnumerated,
  4137.                                                         (Ptr)&mySaveOpt,
  4138.                                                         sizeof(mySaveOpt));
  4139.         /*
  4140.             send the event
  4141.         */
  4142.         if (myErr==noErr) 
  4143.             myErr  = AESend(&myAppleEvent,
  4144.                                             &defReply,
  4145.                                             kAENoReply+kAEAlwaysInteract,
  4146.                                             kAENormalPriority,
  4147.                                             kAEDefaultTimeout,
  4148.                                             nil,
  4149.                                             nil);
  4150.                         
  4151.         if (myAppleEvent.dataHandle) 
  4152.             ignoreErr = AEDisposeDesc(&myAppleEvent);
  4153.             
  4154.         if (selfAddr.dataHandle) 
  4155.             ignoreErr = AEDisposeDesc(&selfAddr);
  4156.             
  4157.         return(myErr);
  4158.     }    /* IssueQuitCommand */
  4159.  
  4160. /*
  4161.      Name :IssueCreatePublisher
  4162.      Purpose :Interact with user to get Publisher info
  4163.                         and the IssueAECommand to Publish currect selection
  4164. */
  4165. pascal void IssueCreatePublisher(DPtr whichDoc)
  4166.     {
  4167.         AEAddressDesc selfAddr;
  4168.         AEDesc        selTextObj;
  4169.         OSErr         err;
  4170.         OSErr         ignoreErr;
  4171.         AppleEvent    publishCommandEvent;
  4172.         AppleEvent    ignoreReply;
  4173.     
  4174.       publishCommandEvent.dataHandle = nil;
  4175.         selfAddr.dataHandle = nil;
  4176.         selTextObj.dataHandle = nil;
  4177.         
  4178.         err = MakeSelfAddress(&selfAddr);
  4179.         
  4180.         if (err==noErr)
  4181.             err = MakeSelectedTextObj(whichDoc->theWindow, whichDoc->theText, &selTextObj);
  4182.                                                             
  4183.         err = AECreateAppleEvent( kAEMiscStandards,
  4184.                                   kAECreatePublisher,
  4185.                                                             &selfAddr,
  4186.                                                             0,
  4187.                                                             0,
  4188.                                                             &publishCommandEvent) ;                
  4189.  
  4190.         /* 
  4191.             add parameter - the text to publish
  4192.         */    
  4193.  
  4194.         if (err==noErr) 
  4195.             err = AEPutParamDesc(&publishCommandEvent, keyDirectObject, &selTextObj);
  4196.             
  4197.         if (err==noErr) 
  4198.             err = AESend(&publishCommandEvent,&ignoreReply,kAENoReply+kAEAlwaysInteract,kAEHighPriority,10000,nil, nil);
  4199.     
  4200.       if (publishCommandEvent.dataHandle)
  4201.             ignoreErr = AEDisposeDesc(&publishCommandEvent);
  4202.         
  4203.         if (selTextObj.dataHandle) 
  4204.             ignoreErr = AEDisposeDesc(&selTextObj);
  4205.             
  4206.         if (selfAddr.dataHandle) 
  4207.             ignoreErr = AEDisposeDesc(&selfAddr);
  4208.             
  4209.     } /*IssueCreatePublisher*/
  4210.     
  4211. #define kOK 1
  4212. #define kCancel 2
  4213. #define kOtherSize 4
  4214. #define kOutlineItem 5
  4215.  
  4216. pascal Boolean PoseSizeDialog(long *whatSize)
  4217.   {
  4218.       GrafPtr   savedPort;
  4219.     DialogPtr aDialog;
  4220.       Str255    aString;
  4221.       short     itemHit;
  4222.  
  4223.         GetPort(&savedPort);
  4224.         aDialog = GetNewDialog(1004, nil, (WindowPtr)-1);
  4225.         ShowWindow(aDialog);
  4226.         SetPort(aDialog);
  4227.         
  4228.         AdornDefaultButton(aDialog, kOutlineItem);
  4229.          
  4230.         /*set the edittext button to contain the right size*/
  4231.         NumToString(*whatSize, aString);
  4232.         SetText(aDialog, kOtherSize, aString);
  4233.      
  4234.         do {
  4235.             ModalDialog(nil, &itemHit);
  4236.         } while ((itemHit!=kOK) && (itemHit!=kCancel));
  4237.         
  4238.         if (itemHit == kOK) 
  4239.             RetrieveText(aDialog, kOtherSize, aString);
  4240.     
  4241.         DisposDialog(aDialog);
  4242.         SetPort(savedPort);
  4243.         
  4244.         if (itemHit == kOK) 
  4245.          {
  4246.              /*set the new size of the text*/
  4247.              StringToNum(aString, whatSize);
  4248.              if ((*whatSize<1) || (*whatSize>2000)) 
  4249.                  *whatSize = 12;
  4250.          }
  4251.         return(itemHit == kOK);
  4252.     }
  4253.     
  4254. pascal void IssueSizeCommand(DPtr theDocument,short theItem)
  4255.     {
  4256.         Str255        name;
  4257.         AEDesc        sizeDesc;
  4258.         AEAddressDesc theAddress;
  4259.         OSErr         err;
  4260.         AEDesc        selTextObj;
  4261.         
  4262.         /*
  4263.             Vars to do with menu processing
  4264.         */
  4265.         short     lastSize;
  4266.         short     upItem;
  4267.         short     downItem;
  4268.         short     otherItem;
  4269.         long      theSize;
  4270.         TextStyle theStyle;
  4271.         short     lineHeight;
  4272.         short     fontAscent;
  4273.             
  4274.         err = MakeSelfAddress(&theAddress);
  4275.         
  4276.         err = MakeSelectedTextObj(theDocument->theWindow, theDocument->theText, &selTextObj);        
  4277.  
  4278.      /*check if the item is on the Size menu*/
  4279.      /*remembering that we can add and delete items from it*/
  4280.      lastSize  = CountMItems(myMenus[sizeM]) - 5;
  4281.      upItem    = lastSize + 2;
  4282.      downItem  = upItem + 1;
  4283.      otherItem = downItem + 2;
  4284.       
  4285.      TEGetStyle((**(theDocument->theText)).selStart,
  4286.                 &theStyle,
  4287.                             &lineHeight,
  4288.                             &fontAscent,
  4289.                             theDocument->theText);
  4290.         
  4291.      GetItem(myMenus[sizeM], theItem, name);
  4292.      
  4293.      if (theItem <= lastSize)
  4294.        {
  4295.          GetItem(myMenus[sizeM], theItem, name);
  4296.        StringToNum(name, &theSize);
  4297.        }
  4298.      else
  4299.        if (theItem == upItem)  
  4300.             theSize = theStyle.tsSize+1;
  4301.          else
  4302.             if (theItem == downItem)
  4303.                       theSize = theStyle.tsSize-1;
  4304.                  else 
  4305.                     if (theItem == otherItem) 
  4306.                         {
  4307.                           theSize = theStyle.tsSize;
  4308.                             if (!PoseSizeDialog(&theSize))
  4309.                                 return;
  4310.                         }
  4311.  
  4312.         if (err==noErr)
  4313.           err = CreateOffsetDescriptor(theSize, &sizeDesc);
  4314.             
  4315.         if (err==noErr)
  4316.             err = SendAESetObjProp(&selTextObj, 
  4317.                                                          pPointSize,
  4318.                                                          &sizeDesc,
  4319.                                                          &theAddress);
  4320.                                                      
  4321.     } /*IssueSizeCommand*/
  4322.     
  4323. pascal void IssueStyleCommand(DPtr theDocument, short theItem)
  4324.     {
  4325.         Style         theFace;
  4326.         OSErr         err;
  4327.         AEDesc        result;
  4328.         AEAddressDesc selfAddr;
  4329.         AEDesc        selTextObj;
  4330.         TextStyle     theStyle;
  4331.         short         lineHeight;
  4332.         short         fontAscent;
  4333.             
  4334.         TEGetStyle((**(theDocument->theText)).selStart,
  4335.                    &theStyle,
  4336.                              &lineHeight,
  4337.                              &fontAscent,
  4338.                              theDocument->theText);
  4339.         
  4340.         theFace = 0;
  4341.     switch (theItem) {
  4342.             case cPlain              : theFace = 0;
  4343.                                 break;
  4344.             case cBold                : theFace = bold;
  4345.                                 break;
  4346.             case cItalic            : theFace = italic;
  4347.                                 break;
  4348.             case cUnderline      : theFace = underline;
  4349.                                 break;
  4350.             case cOutline          : theFace = outline;
  4351.                                 break;
  4352.             case cShadow            : theFace = shadow;
  4353.                                 break;
  4354.             case cCondense        : theFace = condense;
  4355.                                 break;
  4356.             case cExtend            : theFace = extend;
  4357.                                 break;
  4358.     } /*of case */
  4359.  
  4360.     if (theFace==0)
  4361.             err = BuildTypeTextStylesDesc(0, bold+italic+underline+outline+shadow+condense+extend, &result);
  4362.     else
  4363.       if (theFace & theStyle.tsFace)
  4364.               err = BuildTypeTextStylesDesc(0, theFace, &result);
  4365.             else
  4366.               err = BuildTypeTextStylesDesc(theFace, 0, &result);
  4367.         
  4368.         err = MakeSelfAddress(&selfAddr);
  4369.         
  4370.         if (err==noErr)
  4371.             err = MakeSelectedTextObj(theDocument->theWindow, theDocument->theText, &selTextObj);
  4372.         
  4373.         if (err==noErr)
  4374.             err = SendAESetObjProp(&selTextObj, 
  4375.                                                          pTextStyles,
  4376.                                                          &result,
  4377.                                                          &selfAddr);
  4378.         
  4379.     } /* IssueStyleCommand */
  4380.     
  4381. enum {
  4382.  
  4383. ETX = 0x03, /* Enter key on keyboard or keypad */
  4384. BS  = 0x08, /* Backspace key on keyboard       */
  4385. HT  = 0x09, /* Tab key on keyboard             */
  4386. CR  = 0x0D, /* Return key on keyboard          */
  4387. ESC = 0x1B, /* Clear key on keypad             */
  4388. FS  = 0x1C, /* Left arrow key on keypad        */
  4389. GS  = 0x1D, /* Right arrow key on keypad       */
  4390. RS  = 0x1E, /* Up arrow key on keypad          */
  4391. US  = 0x1F  /* Down arrow key on keypad        */
  4392. };
  4393.  
  4394. pascal OSErr IssueSetDataObjToBufferContents(const AEDesc * theObj)
  4395.     { 
  4396.       OSErr         myErr;
  4397.         OSErr                    ignoreErr;
  4398.         AEAddressDesc theAddress;
  4399.         AppleEvent    myAppleEvent;
  4400.         AppleEvent    defReply;
  4401.  
  4402.         myErr = MakeSelfAddress(&theAddress);
  4403.         
  4404.         /* create event */
  4405.         
  4406.         if (myErr==noErr)
  4407.             myErr = AECreateAppleEvent(kAECoreSuite,
  4408.                                                                  kAESetData,
  4409.                                                                  &theAddress,
  4410.                                                                  0,
  4411.                                                                  0,
  4412.                                                                  &myAppleEvent);
  4413.             
  4414.         /* add prop obj spec to the event */
  4415.         
  4416.         if (myErr==noErr)
  4417.             myErr = AEPutParamDesc(&myAppleEvent, keyDirectObject, theObj);
  4418.         
  4419.         /* add prop data to the event */
  4420.         
  4421.         if (myErr==noErr)
  4422.             myErr = AEPutParamPtr(&myAppleEvent,
  4423.                                                         keyAEData,
  4424.                                                         typeChar,
  4425.                                                         (Ptr)gTypingBuffer,
  4426.                                                         gCharsInBuffer);
  4427.                                                         
  4428.         /* send event */
  4429.         
  4430.         if (myErr==noErr)
  4431.          if (gRecordingImplemented)
  4432.              myErr = AESend(&myAppleEvent,
  4433.                                          &defReply,
  4434.                                          kAENoReply+kAEDontExecute,
  4435.                                          kAENormalPriority,
  4436.                                          kAEDefaultTimeout,
  4437.                                          nil,
  4438.                                          nil);
  4439.  
  4440.         if (theAddress.dataHandle)
  4441.             ignoreErr = AEDisposeDesc(&theAddress);
  4442.             
  4443.         if (myAppleEvent.dataHandle)
  4444.             ignoreErr = AEDisposeDesc(&myAppleEvent);
  4445.             
  4446.         return(myErr);
  4447.     }
  4448.  
  4449. pascal void AddKeyToTypingBuffer(DPtr theDocument, char theKey)
  4450.     {
  4451.         OSErr myErr;
  4452.         OSErr ignoreErr;
  4453.         
  4454.         if (theKey==BS || theKey==FS || theKey==GS || theKey==RS || theKey==US)
  4455.             {
  4456.                 FlushAndRecordTypingBuffer();
  4457.                 if (theKey==BS)
  4458.                     {
  4459.                         if ((**theDocument->theText).selStart!=(**theDocument->theText).selEnd)
  4460.                             {
  4461.                                 myErr = MakeTextObj(theDocument->theWindow,
  4462.                                                                         (**theDocument->theText).selStart,
  4463.                                                                         (**theDocument->theText).selEnd,
  4464.                                                                         &gTypingTargetObject);
  4465.                             }
  4466.                         else
  4467.                             {
  4468.                                 myErr = MakeTextObj(theDocument->theWindow,
  4469.                                                                         (**theDocument->theText).selStart-1,
  4470.                                                                         (**theDocument->theText).selStart,
  4471.                                                                         &gTypingTargetObject);
  4472.                             }
  4473.                             
  4474.                     myErr = IssueSetDataObjToBufferContents(&gTypingTargetObject);
  4475.                         
  4476.                         ignoreErr = AEDisposeDesc(&gTypingTargetObject);
  4477.                         
  4478.                         gTypingTargetObject.dataHandle = nil;
  4479.                     }
  4480.             }
  4481.         else
  4482.             {
  4483.                 if (gCharsInBuffer==0)
  4484.                     myErr = MakeSelectedTextObj(theDocument->theWindow,
  4485.                                                                             theDocument->theText,
  4486.                                                                             &gTypingTargetObject);
  4487.  
  4488.                 gTypingBuffer[gCharsInBuffer++] = theKey;
  4489.             }
  4490.           
  4491.     }
  4492.     
  4493. pascal void FlushAndRecordTypingBuffer(void)
  4494.     { 
  4495.       OSErr  myErr;
  4496.         OSErr  ignoreErr;
  4497.  
  4498.         if (gCharsInBuffer != 0)
  4499.             {
  4500.                 myErr = IssueSetDataObjToBufferContents(&gTypingTargetObject);
  4501.                 
  4502.                 if (gTypingTargetObject.dataHandle)
  4503.                     ignoreErr = AEDisposeDesc(&gTypingTargetObject);
  4504.             }
  4505.             
  4506.         gCharsInBuffer = 0;
  4507.         gTypingTargetObject.dataHandle = 0;
  4508.     }
  4509.     
  4510. /*****************************************************************************/
  4511. /*
  4512.     Object Accessors
  4513. */
  4514.     
  4515. pascal OSErr WindowFromNullAccessor(DescType      wantClass,
  4516.                                                                     const AEDesc  *container,
  4517.                                                                         DescType      containerClass,
  4518.                                                                         DescType      form, 
  4519.                                                                         const AEDesc  *selectionData,
  4520.                                                                         AEDesc        *value,
  4521.                                                                         long          theRefCon)
  4522.     {
  4523. #pragma unused (container,theRefCon)
  4524.     
  4525.         OSErr       myErr;
  4526.         Str255      nameStr;
  4527.         WindowToken theWindow;
  4528.         short       index;
  4529.         AEDesc      resultDesc;
  4530.         
  4531.         myErr = errAEBadKeyForm;    /* or whatever */
  4532.         
  4533.         value->dataHandle     = nil;
  4534.         resultDesc.dataHandle = nil;
  4535.         
  4536.         /* 
  4537.             should only be called with wantClass = cWindow and
  4538.             with containerClass = typeNull or typeMyAppl.
  4539.             Currently accept as either formName or formAbsolutePosition
  4540.         */
  4541.         
  4542.         if ((wantClass != cWindow) || 
  4543.               ((containerClass != typeNull) && (containerClass != typeMyAppl)) ||
  4544.                !((form == formName) || (form == formAbsolutePosition)))
  4545.             return(errAEWrongDataType);
  4546.         
  4547.         if (form == formName)
  4548.             {
  4549.                 myErr     = GetPStringFromDescriptor(selectionData, (char *)nameStr);
  4550.                 theWindow = WindowNameToWindowPtr(nameStr);
  4551.             }
  4552.         
  4553.         if (form == formAbsolutePosition)
  4554.             {
  4555.                 myErr         = GetIntegerFromDescriptor(selectionData, &index);
  4556.                 
  4557.                 if (index<0)
  4558.                     index = CountWindows()+index+1;
  4559.                     
  4560.                 theWindow = GetWindowPtrOfNthWindow(index);
  4561.             }
  4562.             
  4563.         if (myErr == noErr)
  4564.             myErr = AECreateDesc(typeMyWndw, (Ptr)&theWindow, sizeof(theWindow), value);
  4565.                 
  4566.         return(myErr);
  4567.     }    /* WindowFromNullAccessor */
  4568.  
  4569. pascal OSErr ApplicationFromNullAccessor(DescType      wantClass,
  4570.                                                                                  const AEDesc  *container,
  4571.                                                                                  DescType      containerClass,
  4572.                                                                                  DescType      form, 
  4573.                                                                                  const AEDesc  *selectionData,
  4574.                                                                                  AEDesc        *value,
  4575.                                                                                  long          theRefCon)
  4576.     {
  4577. #pragma unused (container,selectionData,theRefCon)
  4578.  
  4579.         OSErr    myErr;
  4580.         appToken theApp;
  4581.         AEDesc   resultDesc;
  4582.         
  4583.         value->dataHandle     = nil;
  4584.         resultDesc.dataHandle = nil;
  4585.         
  4586.         /* 
  4587.             should only be called with wantClass = cWindow and
  4588.             with containerClass = typeNull.
  4589.             Currently accept as either formName or formAbsolutePosition
  4590.         */
  4591.         
  4592.         if ((wantClass != cApplication) || (containerClass != typeNull) ||
  4593.               !((form == formName) || (form == formAbsolutePosition)))
  4594.             return(errAEWrongDataType);
  4595.         
  4596.         if ((form == formName) || (form == formAbsolutePosition))
  4597.             {
  4598.                 theApp.highLongOfPSN = 0;
  4599.                 theApp.lowLongOfPSN  = kCurrentProcess;
  4600.             }
  4601.             
  4602.         myErr = AECreateDesc(typeMyAppl, (Ptr)&theApp, sizeof(theApp), value);
  4603.                 
  4604.         return(myErr);
  4605.     }    /* ApplicationFromNullAccessor */
  4606.  
  4607. pascal void MoveToNonSpace(short *start, short limit, charsHandle myChars)
  4608.     /*
  4609.         Treats space,comma, full stop, ; and : as space chars
  4610.     */
  4611.     { 
  4612.         short x;
  4613.  
  4614.         while (*start<=limit) {
  4615.           x = (**myChars)[*start];
  4616.             if ( x == ' ' ||
  4617.                  x == ',' ||
  4618.                  x == '.' ||
  4619.                  x == ',' ||
  4620.                  x == ':' ||
  4621.                  x == 10  ||
  4622.                  x == 13 )
  4623.                 (*start) +=1;
  4624.             else
  4625.                 return;
  4626.         }
  4627.     }
  4628.     
  4629. pascal void MoveToSpace(short *start, short limit, charsHandle myChars)
  4630.     /*
  4631.         Treats space,comma, full stop, ; and : as space chars
  4632.     */
  4633.     { 
  4634.       short x;
  4635.         
  4636.         while (*start<=limit) {
  4637.           x = (**myChars)[*start];
  4638.             if ( x != ' ' &&
  4639.                  x != ',' &&
  4640.                  x != '.' &&
  4641.                  x != ',' &&
  4642.                  x != ':' &&
  4643.                  x != 10  &&
  4644.                  x != 13 )
  4645.                 (*start) +=1;
  4646.             else
  4647.                 return;
  4648.         }
  4649.     }
  4650.  
  4651. pascal short CountWords(TEHandle inTextHandle, short startAt, short forHowManyChars)
  4652.     {
  4653.         charsHandle myChars;
  4654.         short       start;
  4655.         short       limit;
  4656.         short       myWords;
  4657.             
  4658.         myChars  = (charsHandle)(**inTextHandle).hText;
  4659.         limit    = startAt+forHowManyChars-1;
  4660.         start    = startAt;
  4661.         myWords  = 0;
  4662.         MoveToNonSpace(&start, limit, myChars);
  4663.         while (start<=limit) {
  4664.                 myWords++;
  4665.                 MoveToSpace(&start, limit, myChars);
  4666.                 MoveToNonSpace(&start, limit, myChars);
  4667.             }
  4668.         return(myWords);
  4669.     } /* CountWords */
  4670.     
  4671. pascal void GetNthWordInfo(short    whichWord,
  4672.                                                    TEHandle inTextHandle,
  4673.                                                    short    *wordStartChar,
  4674.                                                    short    *wordLength)
  4675.     /*
  4676.         On entry:    wordStartChar is start of char range to count in
  4677.                             wordLength is number of chars to consider
  4678.                             
  4679.         On Exit : wordStartChar is start of requested word
  4680.                             wordLength is number of chars in word
  4681.     */
  4682.     {
  4683.         charsHandle myChars;
  4684.         short       start;
  4685.         short       limit;
  4686.             
  4687.         myChars  = (charsHandle)(**inTextHandle).hText;
  4688.         limit    = *wordStartChar + *wordLength-1;
  4689.         start    = *wordStartChar;
  4690.         MoveToNonSpace(&start, limit, myChars);
  4691.         while ((start<=limit) && (whichWord>0)) {
  4692.  
  4693.                 whichWord       = whichWord-1;
  4694.                 *wordStartChar  = start;
  4695.                 MoveToSpace(&start, limit, myChars);
  4696.                 *wordLength     = start- *wordStartChar;
  4697.                     
  4698.                 MoveToNonSpace(&start, limit, myChars);
  4699.             }
  4700.     } /* GetNthWordInfo */
  4701.     
  4702. pascal void GetWordInfo(short    whichWord,
  4703.                                               TEHandle inTextHandle,
  4704.                                               short    *wordStartChar,
  4705.                                               short    *wordLength)
  4706.     /*
  4707.         On wordStartChar entry is start of char range to count in
  4708.                             wordLength is number of chars to consider
  4709.                             
  4710.         On Exit : wordStartChar is start of requested word
  4711.                             wordLength is number of chars in word
  4712.     */
  4713.     {
  4714.         short noOfWords;
  4715.                     
  4716.         noOfWords = CountWords(inTextHandle, *wordStartChar, *wordLength);
  4717.         
  4718.         if (whichWord<0)
  4719.             whichWord = noOfWords + whichWord + 1;
  4720.             
  4721.         if (whichWord>noOfWords)
  4722.             {
  4723.                 *wordStartChar = *wordStartChar+*wordLength;
  4724.                 *wordLength    = 0;
  4725.             }
  4726.         else
  4727.             GetNthWordInfo(whichWord, inTextHandle, wordStartChar, wordLength);
  4728.     }
  4729.     
  4730. pascal short CountLines(TEHandle inTextHandle)
  4731.     {
  4732.         /*
  4733.             CountLines makes use of info in TERec
  4734.         */
  4735.         return((**inTextHandle).nLines);
  4736.     }
  4737.     
  4738. pascal short LineOfOffset(TEHandle theHTE, short charOffset)
  4739.     {
  4740.         short n;
  4741.     
  4742.         n = (**theHTE).nLines;
  4743.         
  4744.         while (((**theHTE).lineStarts[n-1]>charOffset) &&
  4745.                      (n>0))
  4746.              n--;
  4747.             
  4748.         return(n);
  4749.     } /* LineOfOffset */
  4750.  
  4751. pascal void GetLineInfo(short    whichLine,
  4752.                                                 TEHandle inTextHandle,
  4753.                                               short    *lineStartChar,
  4754.                                               short    *lineLength)
  4755.     {
  4756.         short       noOfLines;
  4757.         charsHandle myChars;
  4758.             
  4759.         /* Addition of lines within text object */
  4760.         short       lineOfStart;
  4761.         short       lineOfEnd;
  4762.         
  4763.         lineOfStart = LineOfOffset(inTextHandle, *lineStartChar);
  4764.         lineOfEnd   = LineOfOffset(inTextHandle, *lineStartChar+*lineLength-1);
  4765.             
  4766.         myChars   = (charsHandle)(**inTextHandle).hText;
  4767.         noOfLines = lineOfEnd - lineOfStart + 1;
  4768.         
  4769.         if (whichLine<0)
  4770.             whichLine = noOfLines + whichLine + 1;
  4771.             
  4772.         noOfLines = CountLines(inTextHandle);
  4773.         whichLine = whichLine + lineOfStart - 1; /* convert offset relative to offset absolute */
  4774.         
  4775.         /* End of addition */
  4776.         
  4777.         if (whichLine<=lineOfEnd)
  4778.             {
  4779.                 *lineStartChar = (**inTextHandle).lineStarts[whichLine-1];
  4780.                 if (whichLine==noOfLines)
  4781.                     *lineLength  = (**inTextHandle).teLength;
  4782.                 else
  4783.                     *lineLength  = (**inTextHandle).lineStarts[whichLine];
  4784.                 *lineLength    = *lineLength-*lineStartChar;
  4785.                 /*
  4786.                     Don't return CR
  4787.                 */
  4788.                 if ((**myChars)[ *lineStartChar+*lineLength-1] == 13)
  4789.                     *lineLength = *lineLength-1;
  4790.             }
  4791.         else
  4792.             {
  4793.                 if (whichLine<noOfLines)
  4794.                   *lineStartChar = (**inTextHandle).lineStarts[whichLine]; /* start of whichLine++ */
  4795.                 else
  4796.                     *lineStartChar = (**inTextHandle).teLength;
  4797.                 *lineLength    = 0;
  4798.             }
  4799.     } /* GetLineInfo */
  4800.     
  4801. pascal OSErr TextElemFromWndwAccessor(DescType     wantClass,
  4802.                                                                         const AEDesc *container,
  4803.                                                                         DescType     containerClass,
  4804.                                                                         DescType     form,
  4805.                                                                         const AEDesc *selectionData,
  4806.                                                                         AEDesc       *value,
  4807.                                                                             long         theRefCon)
  4808.   { 
  4809. #pragma unused (theRefCon)
  4810.     
  4811.         OSErr       myErr;
  4812.         OSErr       ignoreErr;
  4813.         WindowToken theWindow;
  4814.         Size        actSize;
  4815.         long        index;
  4816.         TextToken   theTextToken;
  4817.         AERecord    selectionRecord;
  4818.         TextToken   startText;
  4819.         TextToken   stopText;
  4820.         DescType    returnedType;
  4821.         AEDesc      windDesc;
  4822.         TEHandle    theHTE;
  4823.         DPtr        theDocument;
  4824.         short       wordStartChar;
  4825.         short       wordLength;
  4826.     
  4827.         myErr = -1700;    /* or whatever */
  4828.         
  4829.         selectionRecord.dataHandle = nil;
  4830.         
  4831.         /* do some checking for robustness' sake */
  4832.         
  4833.         if ((containerClass != cWindow) ||
  4834.               ((wantClass != cChar) && 
  4835.                  (wantClass != cSpot) && 
  4836.                  (wantClass != cWord) &&
  4837.                  (wantClass != cLine)    ) ||
  4838.               ((form!=formRange) && (form!=formAbsolutePosition)))
  4839.             return(errAEWrongDataType);
  4840.             
  4841.         /* let's get the window which contains the text element */
  4842.         
  4843.         myErr = AECoerceDesc(container, typeMyWndw, &windDesc);
  4844.         GetRawDataFromDescriptor(    &windDesc,
  4845.                                                             (Ptr)&theWindow,
  4846.                                                             sizeof(theWindow),
  4847.                                                             &actSize);
  4848.         myErr = AEDisposeDesc(&windDesc);
  4849.                                                             
  4850.         if (theWindow==nil)
  4851.             myErr = errAEIllegalIndex;
  4852.         else
  4853.             {
  4854.                                                                                     
  4855.                 theTextToken.tokenWindow = theWindow;
  4856.                 
  4857.                 theDocument = DPtrFromWindowPtr(theTextToken.tokenWindow);
  4858.                 theHTE      = theDocument->theText;
  4859.                 
  4860.                 if (form == formAbsolutePosition)
  4861.                     {
  4862.                         myErr = GetLongIntFromDescriptor(selectionData, &index);
  4863.                         
  4864.                         if (wantClass==cSpot)
  4865.                             {
  4866.                               if (index<0)
  4867.                                     theTextToken.tokenOffset = (**theHTE).teLength+index+2; /* Past last char */
  4868.                                 else
  4869.                                     theTextToken.tokenOffset = index;
  4870.                                     
  4871.                                 theTextToken.tokenLength = 0;
  4872.                             }
  4873.                             
  4874.                         if (wantClass==cChar)
  4875.                             {
  4876.                                 if (index<0)
  4877.                                     theTextToken.tokenOffset = (**theHTE).teLength+index+1;
  4878.                                 else
  4879.                                   theTextToken.tokenOffset = index;
  4880.                                     
  4881.                                 theTextToken.tokenLength = 1;
  4882.                             }
  4883.                             
  4884.                         if (wantClass==cWord)
  4885.                             {
  4886.                                 wordStartChar = 0;
  4887.                                 wordLength    = (**theHTE).teLength;
  4888.                                 GetWordInfo(index, theHTE, &wordStartChar, &wordLength); /* zero based */
  4889.                                 theTextToken.tokenOffset = wordStartChar+1;
  4890.                                 theTextToken.tokenLength = wordLength;
  4891.                             }
  4892.                             
  4893.                         if (wantClass==cLine)
  4894.                             {
  4895.                                 wordStartChar = 0;
  4896.                                 wordLength    = (**theHTE).teLength;
  4897.                                 GetLineInfo(index, theHTE, &wordStartChar, &wordLength); /* zero based */
  4898.                                 theTextToken.tokenOffset = wordStartChar+1;
  4899.                                 theTextToken.tokenLength = wordLength;
  4900.                             }
  4901.                     }    /* of formAbsolutePosition */
  4902.                 
  4903.                 if (form == formRange)
  4904.                     {
  4905.                         /* coerce the selection data into an AERecord */
  4906.                         
  4907.                          myErr = AECoerceDesc(selectionData, typeAERecord, &selectionRecord);
  4908.                         
  4909.                         /* get the start object as a text token - 
  4910.                                 this will reenter this proc but as formAbsolutePosition via the coercion handler*/
  4911.                         
  4912.                         myErr =  AEGetKeyPtr(&selectionRecord,
  4913.                                                                  keyAERangeStart,
  4914.                                                                  typeMyText,
  4915.                                                                  &returnedType,
  4916.                                                                  (Ptr)&startText,
  4917.                                                                  sizeof(startText),
  4918.                                                                  &actSize);
  4919.                         
  4920.                         /* now do the same for the stop object */
  4921.                         
  4922.                         if (myErr==noErr)
  4923.                             myErr =  AEGetKeyPtr(&selectionRecord,
  4924.                                                                      keyAERangeStop,
  4925.                                                                      typeMyText,
  4926.                                                                      &returnedType,
  4927.                                                                      (Ptr)&stopText,
  4928.                                                                      sizeof(stopText),
  4929.                                                                      &actSize);
  4930.                         
  4931.                         if (myErr==noErr)
  4932.                             if ((theTextToken.tokenWindow != stopText.tokenWindow) ||
  4933.                                   (theTextToken.tokenWindow != startText.tokenWindow))
  4934.                                 myErr = errAECorruptData;    /* or whatever ????*/
  4935.                             
  4936.                         theTextToken.tokenOffset  = startText.tokenOffset;            
  4937.                         theTextToken.tokenLength  = stopText.tokenOffset +
  4938.                                                                                  stopText.tokenLength - 
  4939.                                                                                  startText.tokenOffset;
  4940.                                                                                  
  4941.                         if (theTextToken.tokenLength<0)
  4942.                             myErr = errAECorruptData;    /* or whatever */
  4943.                                                                              
  4944.                         ignoreErr = AEDisposeDesc(&selectionRecord);
  4945.                         
  4946.                     }    /* of formRange */
  4947.             }
  4948.         
  4949.         /* return theTextToken in a descriptor */
  4950.         
  4951.         if (myErr==noErr)
  4952.             myErr = AECreateDesc(typeMyText,
  4953.                                                      (Ptr)&theTextToken,
  4954.                                                      sizeof(theTextToken),
  4955.                                                      value);
  4956.                 
  4957.         return(myErr);
  4958.     }    /* TextElemFromWndwAccessor */
  4959.  
  4960. pascal OSErr TextElemFromTextAccessor(DescType     wantClass,
  4961.                                                                         const AEDesc *container,
  4962.                                                                         DescType     containerClass,
  4963.                                                                         DescType     form,
  4964.                                                                         const AEDesc *selectionData,
  4965.                                                                         AEDesc       *value,
  4966.                                                                         long         theRefCon)
  4967.     { 
  4968. #pragma unused (theRefCon, containerClass)
  4969.  
  4970.         OSErr       myErr;
  4971.         Size        actSize;
  4972.         long        index;
  4973.         TextToken   theTextToken;
  4974.         AERecord    selectionRecord;
  4975.         TextToken   startText;
  4976.         TextToken   stopText;
  4977.         DescType    returnedType;
  4978.         AEDesc      textDesc;
  4979.         TEHandle    theHTE;
  4980.         short       wordStartChar;
  4981.         short       wordLength;
  4982.         DPtr        theDocument;
  4983.     
  4984.         myErr = -1700;    /* or whatever */
  4985.             
  4986.         /* do some checking for robustness' sake */
  4987.         
  4988.         if (((wantClass != cChar) && 
  4989.                  (wantClass != cSpot) && 
  4990.                  (wantClass != cLine) && 
  4991.                  (wantClass != cWord)) ||
  4992.               ((form != formAbsolutePosition) && (form != formRange)))
  4993.             return(errAEWrongDataType);
  4994.         
  4995.         /* let's get the src text */
  4996.         
  4997.         myErr = AECoerceDesc(container, typeMyText, &textDesc);
  4998.         GetRawDataFromDescriptor(    &textDesc,
  4999.                                                             (Ptr)&theTextToken,
  5000.                                                             sizeof(theTextToken),
  5001.                                                             &actSize);
  5002.                                                             
  5003.         myErr = AEDisposeDesc(&textDesc);
  5004.                                                             
  5005.         theDocument = DPtrFromWindowPtr(theTextToken.tokenWindow);
  5006.         theHTE      = theDocument->theText;
  5007.         
  5008.         if (form == formAbsolutePosition)
  5009.             {
  5010.                 myErr = GetLongIntFromDescriptor(selectionData, &index);
  5011.                 
  5012.                 if (wantClass==cSpot)
  5013.                     {
  5014.                         if (index<0)
  5015.                             theTextToken.tokenOffset = theTextToken.tokenOffset+index+1+theTextToken.tokenLength;
  5016.                         else
  5017.                             theTextToken.tokenOffset = theTextToken.tokenOffset+index-1;
  5018.                         theTextToken.tokenLength = 0;
  5019.                     }
  5020.                     
  5021.                 if (wantClass==cChar)
  5022.                     {
  5023.                         if (index<0)
  5024.                             theTextToken.tokenOffset = theTextToken.tokenOffset+index+1+theTextToken.tokenLength;
  5025.                         else
  5026.                             theTextToken.tokenOffset = theTextToken.tokenOffset+index-1;
  5027.                         theTextToken.tokenLength = 1;
  5028.                     }
  5029.                                     
  5030.                 if (wantClass==cWord)
  5031.                     {
  5032.                         wordStartChar = theTextToken.tokenOffset-1;
  5033.                         wordLength    = theTextToken.tokenLength;
  5034.                         
  5035.                         GetWordInfo(index, theHTE, &wordStartChar, &wordLength);/*zero based*/
  5036.                         
  5037.                         theTextToken.tokenOffset = wordStartChar+1;
  5038.                         theTextToken.tokenLength = wordLength;
  5039.                     }
  5040.                     
  5041.                 if (wantClass==cLine)
  5042.                     {
  5043.                         wordStartChar = theTextToken.tokenOffset-1;
  5044.                         wordLength    = theTextToken.tokenLength;
  5045.                         
  5046.                         GetLineInfo(index, theHTE, &wordStartChar, &wordLength);
  5047.                         
  5048.                         theTextToken.tokenOffset = wordStartChar+1;
  5049.                         theTextToken.tokenLength = wordLength;
  5050.                     }
  5051.     
  5052.             }    /* of formAbsolutePosition */
  5053.         
  5054.         
  5055.         if (form == formRange)
  5056.             {
  5057.                 /* coerce the selection data into an AERecord */
  5058.                 
  5059.                  myErr = AECoerceDesc(selectionData, typeAERecord, &selectionRecord);
  5060.                 
  5061.                 /* get the start object as a text token - 
  5062.                         this will reenter this proc but as formAbsolutePosition via the coercion handler*/
  5063.                 
  5064.                 myErr =  AEGetKeyPtr(&selectionRecord,
  5065.                                                          keyAERangeStart,
  5066.                                                          typeMyText,
  5067.                                                          &returnedType,
  5068.                                                          (Ptr)&startText,
  5069.                                                          sizeof(startText),
  5070.                                                          &actSize);
  5071.                 
  5072.                 /* now do the same for the stop object */
  5073.                 
  5074.                 if (myErr==noErr)
  5075.                     myErr =  AEGetKeyPtr(&selectionRecord,
  5076.                                                              keyAERangeStop,
  5077.                                                              typeMyText,
  5078.                                                              &returnedType,
  5079.                                                              (Ptr)&stopText,
  5080.                                                              sizeof(stopText),
  5081.                                                              &actSize);
  5082.                 
  5083.                 if (myErr==noErr)
  5084.                     if ((theTextToken.tokenWindow != stopText.tokenWindow) ||
  5085.                           (theTextToken.tokenWindow != startText.tokenWindow))
  5086.                         myErr = errAECorruptData;    /* or whatever */
  5087.                     
  5088.                 theTextToken.tokenOffset  = startText.tokenOffset;            
  5089.                 theTextToken.tokenLength  = stopText.tokenOffset +
  5090.                                                                          stopText.tokenLength - 
  5091.                                                                          startText.tokenOffset;
  5092.                                                                      
  5093.                 myErr = AEDisposeDesc(&selectionRecord);
  5094.             }    /* of formRange */
  5095.             
  5096.         /* return theTextToken in a descriptor */
  5097.         
  5098.         myErr = AECreateDesc( typeMyText,
  5099.                                                     (Ptr)&theTextToken,
  5100.                                                     sizeof(theTextToken),
  5101.                                                     value);
  5102.             
  5103.         return(myErr);
  5104.     }    /* TextElemFromTextAccessor */
  5105.  
  5106. pascal OSErr PropertyFromTextAccessor(DescType     wantClass,
  5107.                                                                             const AEDesc *container,
  5108.                                                                             DescType     containerClass,
  5109.                                                                             DescType     form, 
  5110.                                                                             const AEDesc *selectionData,
  5111.                                                                             AEDesc       *value,
  5112.                                                                             long         theRefCon)
  5113.   {
  5114. #pragma unused (theRefCon, containerClass)
  5115.     
  5116.         OSErr         myErr;
  5117.         OSErr         ignoreErr;
  5118.         TextToken     theTextToken;
  5119.         DescType      theProperty;
  5120.         AEDesc        textDesc;
  5121.         AEDesc        propDesc;
  5122.         Size          actualSize;
  5123.         textPropToken myTextProp;
  5124.             
  5125.         value->dataHandle   = nil;
  5126.         textDesc.dataHandle = nil;
  5127.         propDesc.dataHandle = nil;
  5128.         
  5129.         if ((wantClass != cProperty) ||
  5130.                 (form != formPropertyID))
  5131.             {
  5132.                 return(errAEWrongDataType);
  5133.             }
  5134.         
  5135.         /* get the text token */
  5136.         myErr = AECoerceDesc(container, typeMyText, &textDesc);
  5137.         GetRawDataFromDescriptor(    &textDesc,
  5138.                                                             (Ptr)&theTextToken,
  5139.                                                             sizeof(theTextToken),
  5140.                                                             &actualSize);
  5141.                 
  5142.         /* get the property */
  5143.         myErr = AECoerceDesc(selectionData, typeType, &propDesc);
  5144.         GetRawDataFromDescriptor(&propDesc,
  5145.                                                          (Ptr)&theProperty,
  5146.                                                          sizeof(theProperty),
  5147.                                                          &actualSize);
  5148.         /*
  5149.             Combine the two into single token
  5150.         */
  5151.         myTextProp.propertyTextToken = theTextToken;
  5152.         myTextProp.propertyProperty  = theProperty;
  5153.         
  5154.         myErr = AECreateDesc(typeMyTextProp,
  5155.                                                  (Ptr)&myTextProp,
  5156.                                                  sizeof(myTextProp),
  5157.                                                  value);
  5158.             
  5159.         if (textDesc.dataHandle)
  5160.             ignoreErr = AEDisposeDesc(&textDesc);
  5161.             
  5162.         if (propDesc.dataHandle)
  5163.             ignoreErr = AEDisposeDesc(&propDesc);
  5164.             
  5165.         return(myErr);
  5166. }    /* PropertyFromTextAccessor */
  5167.  
  5168. pascal OSErr PropertyFromWndwAccessor(DescType     wantClass,
  5169.                                                                         const AEDesc *container,
  5170.                                                                         DescType     containerClass,
  5171.                                                                         DescType     form, 
  5172.                                                                         const AEDesc *selectionData,
  5173.                                                                         AEDesc       *value,
  5174.                                                                         long         theRefCon)
  5175.   { 
  5176. #pragma unused (theRefCon, containerClass)
  5177.     
  5178.         OSErr           myErr;
  5179.         OSErr           ignoreErr;
  5180.         WindowToken     theWindowToken;
  5181.         DescType        theProperty;
  5182.         AEDesc          windowDesc;
  5183.         AEDesc          propDesc;
  5184.         Size            actualSize;
  5185.         windowPropToken myWindowProp;
  5186.         
  5187.         value->dataHandle     = nil;
  5188.         windowDesc.dataHandle = nil;
  5189.         propDesc.dataHandle   = nil;
  5190.         
  5191.         if ((wantClass != cProperty) ||
  5192.               (form != formPropertyID))
  5193.             {
  5194.                 return(errAEWrongDataType);
  5195.             }
  5196.         
  5197.         /* get the window token - it's the container */
  5198.         
  5199.         myErr = AECoerceDesc(container, typeMyWndw, &windowDesc);
  5200.         GetRawDataFromDescriptor(    &windowDesc,
  5201.                                                             (Ptr)&theWindowToken,
  5202.                                                             sizeof(theWindowToken),
  5203.                                                             &actualSize);
  5204.                                                             
  5205.         /* Check the window exists */
  5206.         
  5207.         if (theWindowToken==nil)
  5208.             myErr = errAEIllegalIndex;
  5209.         else
  5210.             {
  5211.             
  5212.                 /* get the property - it's in the selection data */
  5213.                 
  5214.                 myErr = AECoerceDesc(selectionData, typeType, &propDesc);
  5215.                 GetRawDataFromDescriptor(    &propDesc,
  5216.                                                                     (Ptr)&theProperty,
  5217.                                                                     sizeof(theProperty),
  5218.                                                                     &actualSize);
  5219.                 /*
  5220.                     Combine the two into single token
  5221.                 */
  5222.                 myWindowProp.tokenWindowToken = theWindowToken;
  5223.                 myWindowProp.tokenProperty    = theProperty;
  5224.                 
  5225.                 myErr = AECreateDesc( typeMyWindowProp,
  5226.                                                             (Ptr)&myWindowProp,
  5227.                                                             sizeof(myWindowProp),
  5228.                                                             value);
  5229.             }
  5230.             
  5231.         if (windowDesc.dataHandle)
  5232.             ignoreErr = AEDisposeDesc(&windowDesc);
  5233.             
  5234.         if (propDesc.dataHandle)
  5235.             ignoreErr = AEDisposeDesc(&propDesc);
  5236.             
  5237.         return(myErr);
  5238.   }    /* PropertyFromWndwAccessor */
  5239.  
  5240. pascal OSErr PropertyFromApplAccessor(DescType     wantClass,
  5241.                                                                             const AEDesc *container,
  5242.                                                                             DescType     containerClass,
  5243.                                                                             DescType     form, 
  5244.                                                                             const AEDesc *selectionData,
  5245.                                                                             AEDesc       *value,
  5246.                                                                             long         theRefCon)
  5247.   {
  5248. #pragma unused (theRefCon, containerClass)
  5249.     
  5250.         OSErr         myErr;
  5251.         OSErr         ignoreErr;
  5252.         appToken      theApplToken;
  5253.         DescType      theProperty;
  5254.         AEDesc        applDesc;
  5255.         AEDesc        propDesc;
  5256.         Size          actualSize;
  5257.         applPropToken myApplProp;
  5258.             
  5259.         value->dataHandle     = nil;
  5260.         applDesc.dataHandle   = nil;
  5261.         propDesc.dataHandle   = nil;
  5262.         
  5263.         if ((wantClass != cProperty) ||
  5264.               (form != formPropertyID))
  5265.             {
  5266.                 return(errAEWrongDataType);
  5267.             }
  5268.         
  5269.         /* get the application token - it's the container */
  5270.         
  5271.         myErr = AECoerceDesc(container, typeMyAppl, &applDesc);
  5272.         GetRawDataFromDescriptor(&applDesc,
  5273.                                                          (Ptr)&theApplToken,
  5274.                                                          sizeof(theApplToken),
  5275.                                                          &actualSize);
  5276.                 
  5277.         /* get the property - it's in the selection data */
  5278.         
  5279.         myErr = AECoerceDesc(selectionData, typeType, &propDesc);
  5280.         GetRawDataFromDescriptor(&propDesc,
  5281.                                                          (Ptr)&theProperty,
  5282.                                                          sizeof(theProperty),
  5283.                                                          &actualSize);
  5284.         /*
  5285.             Combine the two into single token
  5286.         */
  5287.         myApplProp.tokenApplToken    = theApplToken;
  5288.         myApplProp.tokenApplProperty = theProperty;
  5289.         
  5290.         myErr = AECreateDesc(typeMyApplProp,
  5291.                                                  (Ptr)&myApplProp,
  5292.                                                  sizeof(myApplProp),
  5293.                                                  value);
  5294.             
  5295.         if (applDesc.dataHandle)
  5296.             ignoreErr = AEDisposeDesc(&applDesc);
  5297.             
  5298.         if (propDesc.dataHandle)
  5299.             ignoreErr = AEDisposeDesc(&propDesc);
  5300.             
  5301.         return(myErr);
  5302. }    /* PropertyFromApplAccessor */
  5303.  
  5304. pascal OSErr MenuNameToMenuToken(const Str255 theName, MenuToken *theToken)
  5305.     {
  5306.         short   index;
  5307.         
  5308.         for (index=appleM; index<=kLastMenu; index++)
  5309.          {
  5310.                 if (IUEqualString(theName, (**(myMenus[index])).menuData)==0)
  5311.                   {
  5312.                         theToken->theTokenMenu = myMenus[index];
  5313.                         theToken->theTokenID   = index+appleID;
  5314.                         return(noErr);
  5315.                     }
  5316.          }
  5317.         return(errAEIllegalIndex);
  5318.     }
  5319.  
  5320. pascal OSErr MenuFromNullAccessor(DescType      wantClass,
  5321.                                                                     const AEDesc  *container,
  5322.                                                                     DescType      containerClass,
  5323.                                                                     DescType      form, 
  5324.                                                                     const AEDesc  *selectionData,
  5325.                                                                     AEDesc        *value,
  5326.                                                                     long          theRefCon)
  5327.     {
  5328. #pragma unused (container,theRefCon)
  5329.     
  5330.         OSErr       myErr;
  5331.         Str255      nameStr;
  5332.         MenuToken   theMenu;
  5333.         short       index;
  5334.         AEDesc      resultDesc;
  5335.         
  5336.         myErr = errAEBadKeyForm;    /* or whatever */
  5337.         
  5338.         value->dataHandle     = nil;
  5339.         resultDesc.dataHandle = nil;
  5340.         
  5341.         /* 
  5342.             should only be called with wantClass = cMenu and
  5343.             with containerClass = typeNull or typeMyAppl.
  5344.             Currently accept as either formName or formAbsolutePosition
  5345.         */
  5346.         
  5347.         if ((wantClass != cMenu) || 
  5348.               ((containerClass != typeNull) && (containerClass != typeMyAppl)) ||
  5349.                !((form == formName) || (form == formAbsolutePosition)))
  5350.             return(errAEWrongDataType);
  5351.         
  5352.         if (form == formName)
  5353.             {
  5354.                 myErr = GetPStringFromDescriptor(selectionData, (char *)nameStr);
  5355.                 myErr = MenuNameToMenuToken(nameStr, &theMenu);
  5356.             }
  5357.         
  5358.         if (form == formAbsolutePosition)
  5359.             {
  5360.                 myErr     = GetIntegerFromDescriptor(selectionData, &index);
  5361.                 if (index<0)
  5362.                     index = kLastMenu + index + 1;
  5363.                     
  5364.                 if (index>0 && index<=kLastMenu+1)
  5365.                     {
  5366.                         theMenu.theTokenMenu = myMenus[index-1];
  5367.                         theMenu.theTokenID   = index-1+appleID;
  5368.                     }
  5369.                 else
  5370.               myErr = errAEIllegalIndex;    /* or whatever */
  5371.             }
  5372.             
  5373.         if (myErr == noErr)
  5374.             myErr = AECreateDesc(typeMyMenu, (Ptr)&theMenu, sizeof(theMenu), value);
  5375.                 
  5376.         return(myErr);
  5377.     }    /* MenuFromNullAccessor */
  5378.  
  5379. pascal OSErr PropertyFromMenuAccessor(DescType     wantClass,
  5380.                                                                             const AEDesc *container,
  5381.                                                                             DescType     containerClass,
  5382.                                                                             DescType     form, 
  5383.                                                                             const AEDesc *selectionData,
  5384.                                                                             AEDesc       *value,
  5385.                                                                             long         theRefCon)
  5386.   {
  5387. #pragma unused (theRefCon, containerClass)
  5388.     
  5389.         OSErr         myErr;
  5390.         OSErr         ignoreErr;
  5391.         MenuToken     theMenuToken;
  5392.         DescType      theProperty;
  5393.         AEDesc        menuDesc;
  5394.         AEDesc        propDesc;
  5395.         Size          actualSize;
  5396.         MenuPropToken myMenuProp;
  5397.             
  5398.         value->dataHandle     = nil;
  5399.         menuDesc.dataHandle   = nil;
  5400.         propDesc.dataHandle   = nil;
  5401.         
  5402.         if ((wantClass != cProperty) ||
  5403.               (form != formPropertyID))
  5404.             {
  5405.                 return(errAEWrongDataType);
  5406.             }
  5407.         
  5408.         /* get the menu token - it's the container */
  5409.         
  5410.         myErr = AECoerceDesc(container, typeMyMenu, &menuDesc);
  5411.         GetRawDataFromDescriptor(&menuDesc,
  5412.                                                          (Ptr)&theMenuToken,
  5413.                                                          sizeof(theMenuToken),
  5414.                                                          &actualSize);
  5415.                 
  5416.         /* get the property - it's in the selection data */
  5417.         
  5418.         myErr = AECoerceDesc(selectionData, typeType, &propDesc);
  5419.         GetRawDataFromDescriptor(&propDesc,
  5420.                                                          (Ptr)&theProperty,
  5421.                                                          sizeof(theProperty),
  5422.                                                          &actualSize);
  5423.         /*
  5424.             Combine the two into single token
  5425.         */
  5426.         myMenuProp.theMenuToken = theMenuToken;
  5427.         myMenuProp.theMenuProp  = theProperty;
  5428.         
  5429.         myErr = AECreateDesc(typeMyMenuProp,
  5430.                                                  (Ptr)&myMenuProp,
  5431.                                                  sizeof(myMenuProp),
  5432.                                                  value);
  5433.             
  5434.         if (menuDesc.dataHandle)
  5435.             ignoreErr = AEDisposeDesc(&menuDesc);
  5436.             
  5437.         if (propDesc.dataHandle)
  5438.             ignoreErr = AEDisposeDesc(&propDesc);
  5439.             
  5440.         return(myErr);
  5441. }    /* PropertyFromMenuAccessor */
  5442.  
  5443. pascal OSErr PropertyFromMenuItemAccessor(DescType     wantClass,
  5444.                                                                                     const AEDesc *container,
  5445.                                                                                     DescType     containerClass,
  5446.                                                                                     DescType     form, 
  5447.                                                                                     const AEDesc *selectionData,
  5448.                                                                                     AEDesc       *value,
  5449.                                                                                     long         theRefCon)
  5450.   {
  5451. #pragma unused (theRefCon, containerClass)
  5452.     
  5453.         OSErr         myErr;
  5454.         OSErr         ignoreErr;
  5455.         MenuItemToken theMenuItemToken;
  5456.         DescType      theProperty;
  5457.         AEDesc        itemDesc;
  5458.         AEDesc        propDesc;
  5459.         Size          actualSize;
  5460.         MenuItemPropToken myItemProp;
  5461.             
  5462.         value->dataHandle     = nil;
  5463.         itemDesc.dataHandle   = nil;
  5464.         propDesc.dataHandle   = nil;
  5465.         
  5466.         if ((wantClass != cProperty) ||
  5467.               (form != formPropertyID))
  5468.             {
  5469.                 return(errAEWrongDataType);
  5470.             }
  5471.         
  5472.         /* get the menu token - it's the container */
  5473.         
  5474.         myErr = AECoerceDesc(container, typeMyMenuItem, &itemDesc);
  5475.         GetRawDataFromDescriptor(&itemDesc,
  5476.                                                          (Ptr)&theMenuItemToken,
  5477.                                                          sizeof(theMenuItemToken),
  5478.                                                          &actualSize);
  5479.                 
  5480.         /* get the property - it's in the selection data */
  5481.         
  5482.         myErr = AECoerceDesc(selectionData, typeType, &propDesc);
  5483.         GetRawDataFromDescriptor(&propDesc,
  5484.                                                          (Ptr)&theProperty,
  5485.                                                          sizeof(theProperty),
  5486.                                                          &actualSize);
  5487.         /*
  5488.             Combine the two into single token
  5489.         */
  5490.         myItemProp.theItemToken  = theMenuItemToken;
  5491.         myItemProp.theItemProp   = theProperty;
  5492.         
  5493.         myErr = AECreateDesc(typeMyItemProp,
  5494.                                                  (Ptr)&myItemProp,
  5495.                                                  sizeof(myItemProp),
  5496.                                                  value);
  5497.             
  5498.         if (itemDesc.dataHandle)
  5499.             ignoreErr = AEDisposeDesc(&itemDesc);
  5500.             
  5501.         if (propDesc.dataHandle)
  5502.             ignoreErr = AEDisposeDesc(&propDesc);
  5503.             
  5504.         return(myErr);
  5505. }    /* PropertyFromMenuItemAccessor */
  5506.  
  5507. pascal OSErr ItemNameToItemIndex(const Str255 theName, MenuHandle theMenu, short *theIndex)
  5508.     {
  5509.         short   index;
  5510.         short   maxItems;
  5511.         Str255  menuName;
  5512.         
  5513.         maxItems = CountMItems(theMenu);
  5514.         
  5515.         for (index=1; index<=maxItems; index++)
  5516.             {
  5517.                 GetItem(theMenu, index, menuName);
  5518.                 if (IUEqualString(theName, menuName)==0)
  5519.                     {
  5520.                         *theIndex = index;
  5521.                         return(noErr);
  5522.                     }
  5523.             }
  5524.         return(errAEIllegalIndex);
  5525.     }
  5526.     
  5527. pascal OSErr MenuItemFromMenuAccessor(DescType     wantClass,
  5528.                                                                             const AEDesc *container,
  5529.                                                                             DescType     containerClass,
  5530.                                                                             DescType     form, 
  5531.                                                                             const AEDesc *selectionData,
  5532.                                                                             AEDesc       *value,
  5533.                                                                             long         theRefCon)
  5534.   {
  5535. #pragma unused (theRefCon)
  5536.     
  5537.         OSErr         myErr;
  5538.         OSErr         ignoreErr;
  5539.         MenuItemToken theMenuItemToken;
  5540.         MenuToken     theMenuToken;
  5541.         AEDesc        menuDesc;
  5542.         Size          actualSize;
  5543.         Str255        nameStr;
  5544.         short         maxItems;
  5545.         short         index;
  5546.             
  5547.         value->dataHandle     = nil;
  5548.         menuDesc.dataHandle   = nil;
  5549.         
  5550.         if ((wantClass != cMenuItem) || (containerClass != cMenu) ||
  5551.               ((form != formAbsolutePosition) && (form != formName)))
  5552.             {
  5553.                 return(errAEWrongDataType);
  5554.             }
  5555.         
  5556.         /* get the menu token - it's the container */
  5557.         
  5558.         myErr = AECoerceDesc(container, typeMyMenu, &menuDesc);
  5559.         GetRawDataFromDescriptor(&menuDesc,
  5560.                                                          (Ptr)&theMenuToken,
  5561.                                                          sizeof(theMenuToken),
  5562.                                                          &actualSize);
  5563.                 
  5564.         if (form==formAbsolutePosition)
  5565.             {
  5566.                 myErr = GetIntegerFromDescriptor(selectionData, &index);
  5567.                 maxItems = CountMItems(theMenuToken.theTokenMenu);
  5568.                 
  5569.                 if (index<0)
  5570.                     index = maxItems + index + 1;
  5571.                     
  5572.                 if ((index<1) || (index>maxItems))
  5573.                   myErr = errAEIllegalIndex;
  5574.             }
  5575.             
  5576.         if (form == formName)
  5577.             {
  5578.                 myErr  = GetPStringFromDescriptor(selectionData, (char *)nameStr);
  5579.                 myErr  = ItemNameToItemIndex(nameStr, theMenuToken.theTokenMenu, &index);
  5580.             }
  5581.         
  5582.         /*
  5583.             Combine the two into single token
  5584.         */
  5585.     
  5586.         theMenuItemToken.theMenuToken  = theMenuToken;
  5587.         theMenuItemToken.theTokenItem  = index;
  5588.         
  5589.         if (myErr==noErr)
  5590.             myErr = AECreateDesc(typeMyMenuItem,
  5591.                                                      (Ptr)&theMenuItemToken,
  5592.                                                      sizeof(theMenuItemToken),
  5593.                                                      value);
  5594.             
  5595.         if (menuDesc.dataHandle)
  5596.             ignoreErr = AEDisposeDesc(&menuDesc);
  5597.             
  5598.         return(myErr);
  5599. }    /* MenuItemFromMenuAccessor */
  5600.  
  5601. /*******************************************************************************/
  5602. /*
  5603.     Stuff for counting objects
  5604. */
  5605.  
  5606. pascal OSErr MyCountProc(DescType     desiredType,
  5607.                                                DescType     containerClass,
  5608.                                                const AEDesc *container,
  5609.                                                long         *result)
  5610.                                             
  5611. /* so far all I count is:
  5612.   (1) the number of active windows in the app;
  5613.   (2) the number of words in a window 
  5614. */
  5615.  
  5616.     {   
  5617.         OSErr       myErr;
  5618.         WindowToken theWindowToken;
  5619.         DPtr        theDocument;
  5620.         TEHandle    theHTE;
  5621.         AEDesc      newDesc;
  5622.         short       wordStart;
  5623.         short       wordLength;
  5624.         Size        tokenSize;
  5625.         TextToken   theTextToken;
  5626.             
  5627.         *result = -1;    /* easily recognized illegal value */
  5628.             
  5629.         myErr = errAEWrongDataType;
  5630.         
  5631.         if (desiredType == cWindow)
  5632.             {
  5633.                 if ((containerClass == typeNull) ||
  5634.                       (containerClass == cApplication))
  5635.                     *result = CountWindows();
  5636.             }
  5637.             
  5638.         if ((desiredType == cWord) ||
  5639.               (desiredType == cLine) ||
  5640.               (desiredType == cChar))
  5641.             {
  5642.                 myErr = AECoerceDesc(container, typeMyWndw, &newDesc);
  5643.                 if (newDesc.descriptorType!=typeNull)
  5644.                     {
  5645.                         GetRawDataFromDescriptor(&newDesc,
  5646.                                                                          (Ptr)&theWindowToken,
  5647.                                                                          sizeof(theWindowToken),
  5648.                                                                          &tokenSize);
  5649.                                                                          
  5650.                         myErr = AEDisposeDesc(&newDesc);
  5651.                                                                          
  5652.                         if (theWindowToken==nil)
  5653.                             myErr = errAEIllegalIndex;
  5654.                         else
  5655.                             {
  5656.                         
  5657.                                 theDocument = DPtrFromWindowPtr(theWindowToken);
  5658.                                 theHTE      = theDocument->theText;
  5659.                                 
  5660.                                 if (desiredType == cWord)
  5661.                                     {
  5662.                                         wordStart   = 0;
  5663.                                         wordLength  = (**theHTE).teLength;
  5664.                                         *result     = CountWords(theHTE, wordStart, wordLength);
  5665.                                     }
  5666.                                 
  5667.                                 if (desiredType == cChar)
  5668.                                     *result = (**theHTE).teLength;
  5669.                                     
  5670.                                 if (desiredType == cLine)
  5671.                                     *result = CountLines(theHTE);
  5672.                                     
  5673.                             }
  5674.                     }
  5675.                     
  5676.                 myErr = AECoerceDesc(container, typeMyText, &newDesc);
  5677.                 if (newDesc.descriptorType!=typeNull)
  5678.                     {
  5679.                         GetRawDataFromDescriptor(    &newDesc,
  5680.                                                                             (Ptr)&theTextToken,
  5681.                                                                             sizeof(theTextToken),
  5682.                                                                             &tokenSize);
  5683.                                                                          
  5684.                         myErr = AEDisposeDesc(&newDesc);
  5685.                                                                          
  5686.                         theDocument = DPtrFromWindowPtr(theTextToken.tokenWindow);
  5687.                         theHTE      = theDocument->theText;
  5688.                         
  5689.                         if (desiredType == cWord)
  5690.                             {
  5691.                                 wordStart   = theTextToken.tokenOffset-1;
  5692.                                 wordLength  = theTextToken.tokenLength;
  5693.                                 *result     = CountWords(theHTE, wordStart, wordLength);
  5694.                             }
  5695.                         
  5696.                         if (desiredType == cChar)
  5697.                             *result = theTextToken.tokenLength;
  5698.                             
  5699.                         if (desiredType == cLine)
  5700.                             *result= LineOfOffset(theHTE,theTextToken.tokenOffset-1) - 
  5701.                                              LineOfOffset(theHTE,theTextToken.tokenOffset+theTextToken.tokenLength-1)
  5702.                                              +1;                        
  5703.                     }
  5704.                     
  5705.             }
  5706.             
  5707.         return(myErr);
  5708.     }    /* MyCountProc */
  5709.  
  5710. /*******************************************************************************/
  5711. /*
  5712.     Coercion Handlers - Allow AEResolve to do the hard work
  5713. */
  5714. pascal OSErr CoerceObjToAnything(const AEDesc *theAEDesc,
  5715.                                                              DescType     toType,
  5716.                                                          long         handlerRefCon,
  5717.                                                              AEDesc       *result)
  5718. /*
  5719.     CoerceObjToAnything functions by using AEResolve to do the hard
  5720.     work.
  5721. */
  5722.     {
  5723. #pragma unused (handlerRefCon)
  5724.     
  5725.         OSErr  myErr;
  5726.         AEDesc objDesc;
  5727.             
  5728.         myErr = errAECoercionFail;
  5729.         
  5730.         result->dataHandle = nil;
  5731.         objDesc.dataHandle = nil;
  5732.         
  5733.         
  5734.         if (theAEDesc->descriptorType != typeObjectSpecifier)
  5735.             {
  5736.                 return(errAEWrongDataType);
  5737.             }
  5738.         
  5739.         /* resolve the object specifier */
  5740.         myErr = AEResolve(theAEDesc, kAEIDoMinimum, &objDesc);
  5741.             
  5742.         /* hopefully it's the right type by now, but we'll give it a nudge */
  5743.         if (myErr==noErr)
  5744.             {
  5745.                 myErr = AECoerceDesc(&objDesc, toType, result);
  5746.                 myErr = AEDisposeDesc(&objDesc);
  5747.             }
  5748.             
  5749.         if (result->descriptorType!=toType)
  5750.             {
  5751.                 /*DebugStr('COTA - Not of requested type');*/
  5752.             }
  5753.             
  5754.         return(myErr);
  5755.     }    /* CoerceObjToAnything */
  5756.  
  5757. /*******************************************************************************/
  5758.  
  5759. /*----------------------------------------------------------------------------------------------*/
  5760.  
  5761. /*now for the edition manager event handling code*/
  5762.  
  5763. pascal OSErr GetHandleFromEvent(const AppleEvent *theAppleEvent, SectionHandle *sectionH)
  5764.     
  5765.     {
  5766.         DescType ignoreType;
  5767.         Size          ignoreSize;
  5768.     
  5769.         return(AEGetKeyPtr(theAppleEvent, keyDirectObject, typeSectionH,
  5770.                                              &ignoreType, (Ptr)sectionH, sizeof(SectionHandle), &ignoreSize));
  5771.     } /* GetHandleFromEvent */
  5772.  
  5773. /*----------------------------------------------------------------------------------------------*/
  5774. pascal OSErr DoReadSection(const AppleEvent *theAppleEvent,AppleEvent *reply,long refCon)
  5775.     
  5776.     {
  5777. #pragma unused (reply, refCon)
  5778.     
  5779.         OSErr         err;
  5780.         SectionHandle sectionH;
  5781.     
  5782.         err = GetHandleFromEvent(theAppleEvent, §ionH);
  5783.         if (IsRegisteredSection(sectionH)==noErr)
  5784.             ReadAnEdition(sectionH);
  5785.         return(err);
  5786.     } /* DoReadSection */
  5787.     
  5788. /*----------------------------------------------------------------------------------------------*/
  5789. pascal OSErr DoWriteSection(const AppleEvent *theAppleEvent, AppleEvent *reply, long refCon)
  5790.     
  5791.     {
  5792. #pragma unused (reply, refCon)
  5793.  
  5794.         OSErr         err;
  5795.         SectionHandle sectionH;
  5796.     
  5797.         err = GetHandleFromEvent(theAppleEvent, §ionH);
  5798.         if (IsRegisteredSection(sectionH) == noErr)
  5799.             WriteAnEdition(sectionH);
  5800.         
  5801.         return(err);
  5802.     } /* DoWriteSection */
  5803.  
  5804. /*----------------------------------------------------------------------------------------------*/
  5805. pascal OSErr DoScrollSection(const AppleEvent *theAppleEvent, AppleEvent *reply, long refCon)
  5806.     {
  5807. #pragma unused (reply, refCon)
  5808.     
  5809.         OSErr         err;
  5810.         SectionHandle sectionH;
  5811.         SectHandle    aSectHandle;
  5812.     
  5813.         err = GetHandleFromEvent(theAppleEvent, §ionH);
  5814.         /*get at the sectHandle*/
  5815.         aSectHandle = (SectHandle)GetERefCon(sectionH);
  5816.         TESetSelect((**aSectHandle).fStart, (**aSectHandle).fEnd, ((**aSectHandle).fDocument)->theText);
  5817.         ShowSelect((**aSectHandle).fDocument);
  5818.         return(err);
  5819.     }
  5820.  
  5821. /*----------------------------------------------------------------------------------------------*/
  5822. pascal OSErr DoCancelSection(const AppleEvent *theAppleEvent, AppleEvent *reply, long refCon)
  5823.  
  5824.     {
  5825. #pragma unused (reply, refCon)
  5826.     
  5827.         OSErr         err;
  5828.         SectionHandle sectionH;
  5829.         SectHandle    aSectHandle;
  5830.             
  5831.         err = GetHandleFromEvent(theAppleEvent, §ionH);
  5832.         aSectHandle = (SectHandle)GetERefCon(sectionH);
  5833.         err = UnRegisterSection(sectionH);
  5834.         DeleteASection(aSectHandle, (**aSectHandle).fDocument);
  5835.         return(noErr);
  5836.     } /* DoCancelSection */
  5837.  
  5838. /* -----------------------------------------------------------------------
  5839.         Name:             InitAppleEvents
  5840.         Purpose:        Initialise the AppleEvent despatch table
  5841.      -----------------------------------------------------------------------**/
  5842.  
  5843. #pragma segment Main
  5844.  
  5845. #define noRefCon -1
  5846.  
  5847. pascal void InitAppleEvents(void)
  5848.     {
  5849.          OSErr aevtErr;
  5850.         
  5851.     gBigBrother = 0;
  5852.         gCharsInBuffer = 0;
  5853.         gTypingBuffer  = (char *)NewPtr(32000);
  5854.         gTypingTargetObject.dataHandle = 0;
  5855.         
  5856.         /*set up the despatch table for the four standard apple events*/
  5857.         
  5858.         aevtErr = AEInstallEventHandler( kCoreEventClass, kAEOpenApplication, NewAEEventHandlerProc(DoOpenApp), noRefCon, false) ;
  5859.         aevtErr = AEInstallEventHandler( kCoreEventClass, kAEOpenDocuments,   NewAEEventHandlerProc(DoOpenDocument), noRefCon, false) ;
  5860.         aevtErr = AEInstallEventHandler( kCoreEventClass, kAEPrintDocuments,  NewAEEventHandlerProc(DoPrintDocuments), noRefCon, false) ;
  5861.         aevtErr = AEInstallEventHandler( kCoreEventClass, kAEQuitApplication, NewAEEventHandlerProc(MyQuit), noRefCon, false) ;
  5862.         
  5863.         /* set up the despatch table for the core AppleEvents for text */
  5864.         
  5865.         aevtErr = AEInstallEventHandler( kAECoreSuite,     kAEDelete, NewAEEventHandlerProc(DoDeleteEdit),noRefCon, false);
  5866.  
  5867.         aevtErr = AEInstallEventHandler( kAEMiscStandards, kAECut,    NewAEEventHandlerProc(DoCutEdit),   noRefCon, false);
  5868.         aevtErr = AEInstallEventHandler( kAEMiscStandards, kAECopy,   NewAEEventHandlerProc(DoCopyEdit),  noRefCon, false);
  5869.         aevtErr = AEInstallEventHandler( kAEMiscStandards, kAEPaste,  NewAEEventHandlerProc(DoPasteEdit), noRefCon, false);
  5870.         aevtErr = AEInstallEventHandler( kAECoreSuite,     kAESetData,NewAEEventHandlerProc(DoSetData),   noRefCon, false);
  5871.         aevtErr = AEInstallEventHandler( kAECoreSuite,     kAEGetData,NewAEEventHandlerProc(DoGetData),   noRefCon, false);
  5872.         aevtErr = AEInstallEventHandler( kAECoreSuite,     kAEGetDataSize,NewAEEventHandlerProc(DoGetDataSize),   noRefCon, false);
  5873.         
  5874.         aevtErr = AEInstallEventHandler( kAECoreSuite, kAECountElements,   NewAEEventHandlerProc(HandleNumberOfElements),   noRefCon, false);
  5875.         aevtErr = AEInstallEventHandler( kAECoreSuite, kAECreateElement,   NewAEEventHandlerProc(DoNewElement),   noRefCon, false);
  5876.         aevtErr = AEInstallEventHandler( kAECoreSuite, kAEDoObjectsExist,  NewAEEventHandlerProc(DoIsThereA),   noRefCon, false);
  5877.     
  5878.         aevtErr = AEInstallEventHandler( kAECoreSuite,     kAEClose,  NewAEEventHandlerProc(DoCloseWindow),noRefCon, false);
  5879.         aevtErr = AEInstallEventHandler( kAECoreSuite,     kAESave,   NewAEEventHandlerProc(DoSaveWindow),noRefCon, false);
  5880.         aevtErr = AEInstallEventHandler( kAEMiscStandards, kAERevert, NewAEEventHandlerProc(DoRevertWindow),noRefCon, false);
  5881.         
  5882.         aevtErr = AEInstallEventHandler( kAEMiscStandards, kAECreatePublisher,    NewAEEventHandlerProc(HandleCreatePub), noRefCon, false);
  5883.         aevtErr = AEInstallEventHandler( kAEMiscStandards, kAEMakeObjectsVisible, NewAEEventHandlerProc(HandleShowSelection), noRefCon, false);
  5884.         
  5885.         /* Now look for recording notifications */
  5886.         
  5887.         aevtErr = AEInstallEventHandler( kCoreEventClass, kAEStartedRecording, NewAEEventHandlerProc(HandleStartRecording), noRefCon, false);
  5888.         aevtErr = AEInstallEventHandler( kCoreEventClass, kAEStoppedRecording, NewAEEventHandlerProc(HandleStopRecording), noRefCon, false);
  5889.         
  5890.         /* Now Put in the required object accessors */
  5891.         
  5892.         aevtErr = AESetObjectCallbacks(nil,NewOSLCountProc(MyCountProc),nil,nil,nil,nil,nil);
  5893.         
  5894.         aevtErr = AEInstallObjectAccessor(cWindow,      typeNull,   NewOSLAccessorProc(WindowFromNullAccessor),  0,false);
  5895.         aevtErr = AEInstallObjectAccessor(cWindow,      typeMyAppl, NewOSLAccessorProc(WindowFromNullAccessor),  0,false);
  5896.                 
  5897.         aevtErr = AEInstallObjectAccessor(cApplication, typeNull,   NewOSLAccessorProc(ApplicationFromNullAccessor),  0,false);
  5898.         aevtErr = AEInstallObjectAccessor(cProperty,    typeMyAppl, NewOSLAccessorProc(PropertyFromApplAccessor),0,false);
  5899.         
  5900.         aevtErr = AEInstallObjectAccessor(cChar,             typeMyWndw,NewOSLAccessorProc(TextElemFromWndwAccessor),0,false);
  5901.         aevtErr = AEInstallObjectAccessor(cSpot,             typeMyWndw,NewOSLAccessorProc(TextElemFromWndwAccessor),0,false);
  5902.         aevtErr = AEInstallObjectAccessor(cWord,             typeMyWndw,NewOSLAccessorProc(TextElemFromWndwAccessor),0,false);
  5903.         aevtErr = AEInstallObjectAccessor(cLine,             typeMyWndw,NewOSLAccessorProc(TextElemFromWndwAccessor),0,false);
  5904.         aevtErr = AEInstallObjectAccessor(cProperty,   typeMyWndw,NewOSLAccessorProc(PropertyFromWndwAccessor),0,false);
  5905.     
  5906.         aevtErr = AEInstallObjectAccessor(cProperty,     typeMyText,NewOSLAccessorProc(PropertyFromTextAccessor),0,false);
  5907.         aevtErr = AEInstallObjectAccessor(cChar,           typeMyText,NewOSLAccessorProc(TextElemFromTextAccessor),0,false);
  5908.         aevtErr = AEInstallObjectAccessor(cWord,           typeMyText,NewOSLAccessorProc(TextElemFromTextAccessor),0,false);
  5909.         aevtErr = AEInstallObjectAccessor(cSpot,           typeMyText,NewOSLAccessorProc(TextElemFromTextAccessor),0,false);
  5910.         aevtErr = AEInstallObjectAccessor(cLine,           typeMyText,NewOSLAccessorProc(TextElemFromTextAccessor),0,false);
  5911.         
  5912.         aevtErr = AEInstallObjectAccessor(cMenu,           typeNull,       NewOSLAccessorProc(MenuFromNullAccessor),    0,false);
  5913.         aevtErr = AEInstallObjectAccessor(cProperty,   typeMyMenu,     NewOSLAccessorProc(PropertyFromMenuAccessor),0,false);
  5914.         aevtErr = AEInstallObjectAccessor(cProperty,   typeMyMenuItem, NewOSLAccessorProc(PropertyFromMenuItemAccessor),0,false);
  5915.         aevtErr = AEInstallObjectAccessor(cMenuItem,   typeMyMenu,     NewOSLAccessorProc(MenuItemFromMenuAccessor),0,false);
  5916.         /* Now the coercion handlers */
  5917.  
  5918.       aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyAppl,      (AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything),0,true,false);
  5919.         aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyWndw,      (AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything),0,true,false);
  5920.       aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyText,      (AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything),0,true,false);
  5921.       aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyTextProp,  (AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything),0,true,false);
  5922.       aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyWindowProp,(AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything),0,true,false);
  5923.       aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyApplProp,  (AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything),0,true,false);
  5924.       aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyMenu,      (AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything),0,true,false);
  5925.       aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyMenuProp,  (AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything),0,true,false);
  5926.       aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyMenuItem,  (AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything),0,true,false);
  5927.       aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyItemProp,  (AECoercionHandlerUPP)NewAECoerceDescProc(CoerceObjToAnything),0,true,false);
  5928.         
  5929.         /*now install the appropriate edition manager events*/
  5930.         
  5931.         aevtErr = AEInstallEventHandler( sectionEventMsgClass, sectionReadMsgID,   NewAEEventHandlerProc(DoReadSection), noRefCon, false) ;
  5932.         aevtErr = AEInstallEventHandler( sectionEventMsgClass, sectionWriteMsgID,  NewAEEventHandlerProc(DoWriteSection), noRefCon, false) ;
  5933.         aevtErr = AEInstallEventHandler( sectionEventMsgClass, sectionScrollMsgID, NewAEEventHandlerProc(DoScrollSection), noRefCon, false) ;
  5934.         aevtErr = AEInstallEventHandler( sectionEventMsgClass, sectionCancelMsgID, NewAEEventHandlerProc(DoCancelSection), noRefCon, false) ;
  5935.         
  5936.  } /* InitAppleEvents */
  5937.